class MainWindow(PageWindow):
def __init__(self):
super().__init__()
#self.ser = serial.Serial(port='COM3', baudrate=115200, bytesize=8, parity='N', stopbits=1)
self.seperator_vertical = QVSeperationLine()
self.seperator_horizontal = QHSeperationLine()
self.initUI()
self.setWindowTitle("MainWindow")
def initUI(self):
self.homeUI()
def homeUI(self):
self.preview_widget = QWidget()
self.footer_widget = QWidget()
self.home = True
self.viewfinder = QCameraViewfinder()
self.viewfinder.show()
self.setCentralWidget(self.viewfinder)
self.cap = None # -capture <-> +cap
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout2 = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.image_label = QLabel()
self.image_label.setText("")
self.image_label.setObjectName("image_label")
self.temp = QLabel()
self.temp.setText("Temperature:")
self.temp.setObjectName("temp")
self.temp_reading = QLabel()
self.temp_reading.setText("temp_reading")
self.temp_reading.setObjectName("temp_reading")
self.temp2 = QLabel()
self.temp2.setText("Temperature 2:")
self.temp2.setObjectName("temp2")
self.temp2_reading = QLabel()
self.temp2_reading.setText("Temperature2 Reading")
self.temp2_reading.setObjectName("temp2_reading")
self.image_label.setScaledContents(True)
self.matplotlibWidget = MatplotlibWidget(self)
self.threadSample = ThreadSample(self)
self.threadSample.newSample.connect(self.on_threadSample_newSample)
self.threadSample.finished.connect(self.on_threadSample_finished)
self.gridLayout = QGridLayout(self)
self.gridLayout.addWidget(self.temp, 0, 0)
self.gridLayout.addWidget(self.temp_reading, 0, 1)
self.gridLayout.addWidget(self.temp2, 1, 0)
self.gridLayout.addWidget(self.temp2_reading, 1, 1)
self.horizontalLayout.addWidget(self.image_label)
self.horizontalLayout.addWidget(self.seperator_vertical)
self.horizontalLayout.addLayout(self.gridLayout)
self.preview_widget.setLayout(self.horizontalLayout)
self.preview_widget.setMinimumHeight(200)
self.preview_widget.setMaximumHeight(200)
self.preview_widget.setMinimumWidth(600)
self.preview_widget.setMaximumWidth(600)
self.horizontalLayout2.addWidget(self.matplotlibWidget)
self.horizontalLayout2.addWidget(self.seperator_vertical)
#self.horizontalLayout2.addWidget(self.clock)
self.clock(self.horizontalLayout2)
self.footer_widget.setLayout(self.horizontalLayout2)
self.footer_widget.setMinimumHeight(250)
self.footer_widget.setMaximumHeight(250)
self.footer_widget.setMinimumWidth(600)
self.footer_widget.setMaximumWidth(600)
self.verticalLayout.addWidget(self.preview_widget)
self.verticalLayout.addWidget(self.seperator_horizontal)
self.verticalLayout.addWidget(self.footer_widget)
#self.verticalLayout.addWidget(self.image_label2)
self.timer = QTimer(self, interval=5)
self.timer.timeout.connect(self.update_frame)
self._image_counter = 0
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
self.centralWidget().setLayout(self.verticalLayout)
# self.setCentralWidget(self.scroll)
self.setGeometry(300, 300, 400, 700)
def read_temp(self):
temp = []
while True:
self.ser.write(b'0x55,0xAA,5,1,4')
response = self.ser.readline()
#print(str(response))
if 'body' in str(response):
temp.append(str(response))
#print("temp-"+str(response))
#print(temp)
elif 'Vbat' in str(response):
if len(temp) != 0:
print("Done-" + ' '.join(temp))
self.start_webcam()
self.update_frame(self.filter(''.join(temp)))
temp = []
def filter(self, text):
text = text.replace('bTbody', 'body')
text = text.replace('\'', '')
text = text.replace('\\r\n\'b\'Tbody', '-')
text = text.replace('\\r', '')
text = text.replace('\r', '')
text = text.replace('\\xa8', '')
text = text.replace('\\xa1\\xe6', '')
text = text.replace('\\n', '-')
text = text.replace(' ', '')
text = text.replace(', ', ',')
text = text.replace('=', '_')
text = text.replace(',', '-')
return text
@QtCore.pyqtSlot()
def start_webcam(self):
if self.cap is None:
self.cap = cv2.VideoCapture(0)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
self.timer.start()
def closeEvent(self, event):
print("closing PyQtTest")
self.cap.close()
@QtCore.pyqtSlot()
def update_frame(self, file_name):
ret, image = self.cap.read()
self.face_detect(image, file_name)
simage = cv2.flip(image, 1)
self.displayImage(image, True)
def face_detect(self, image, file_name):
frame = image
face_locations = []
face_encodings = []
face_names = []
process_this_frame = True
i = 0
face_detect = True
# Resize frame of video to 1/4 size for faster face recognition processing
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
self.dirname = 'd:'
# Only process every other frame of video to save time
if process_this_frame:
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(rgb_small_frame)
face_encodings = face_recognition.face_encodings(
rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
face_detect = False
name = "Unknown"
cv2.imwrite(
os.path.abspath(
os.path.join(
self.dirname,
(datetime.today().strftime('%Y-%m-%d') + '-' +
file_name + '-' + str(++i) + '.png'))), frame)
#self.storage.upload(self.dirname,(datetime.today().strftime('%Y-%m-%d')+'-'+file_name+'-'+str(i)+'.png'))
i = i + 1
print("I see someone named {}!".format(name))
# # If a match was found in known_face_encodings, just use the first one.
# if True in matches:
# first_match_index = matches.index(True)
# name = known_face_names[first_match_index]
# Or instead, use the known face with the smallest distance to the new face
process_this_frame = not process_this_frame
@staticmethod
@QtCore.pyqtSlot()
def capture_image(self):
flag, frame = self.cap.read()
timestamp = time.strftime("%d-%b-%Y-%H_%M_%S")
self.save_seq += 1
path = self.save_path #
if flag:
QtWidgets.QApplication.beep()
name = "my_image.jpg"
cv2.imwrite(
os.path.join(
self.save_path, "%s-%04d-%s.jpg" %
(self.current_camera_name, self.save_seq, timestamp)),
frame)
self._image_counter += 1
def displayImage(self, img, window=True):
qformat = QImage.Format_Indexed8
if len(img.shape) == 3:
if img.shape[2] == 4:
qformat = QImage.Format_RGBA8888
else:
qformat = QImage.Format_RGB888
outImage = QImage(img, img.shape[1], img.shape[0], img.strides[0],
qformat)
outImage = outImage.rgbSwapped()
if window:
self.image_label.setStyleSheet("""
QLabel {
height:300px !important;
}
""")
self.image_label.setPixmap(QPixmap.fromImage(outImage))
def clock(self, layout):
self.verticalLayoutClock = QVBoxLayout(self)
self.dateEdit = QDateEdit(self)
self.dateEdit.setDisplayFormat("MMM dd yyyy")
self.dateEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.dateEdit)
self.timeEdit = QTimeEdit(self)
self.timeEdit.setDisplayFormat("hh:mm:ss AP")
self.timeEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.timeEdit)
self.updateTime()
self.timer = QTimer(self)
self.timer.timeout.connect(self.updateTime)
self.timer.start(1000)
layout.addLayout(self.verticalLayoutClock)
@QtCore.pyqtSlot(list)
def on_threadSample_newSample(self, sample):
self.matplotlibWidget.axis.plot(sample)
self.matplotlibWidget.canvas.draw()
@QtCore.pyqtSlot()
def on_threadSample_finished(self):
self.samples += 1
if self.samples <= 2:
self.threadSample.start()
@QtCore.pyqtSlot()
def on_pushButtonPlot_clicked(self):
self.samples = 0
self.matplotlibWidget.axis.clear()
self.threadSample.start()
def updateTime(self):
current = QtCore.QDateTime.currentDateTime()
self.dateEdit.setDate(current.date())
self.timeEdit.setTime(current.time())
class MainWindow(PageWindow):
def __init__(self, dir):
super().__init__()
self.storage = firebase.screening()
try:
self.ser = serial.Serial(port='COM3',
baudrate=115200,
bytesize=8,
parity='N',
stopbits=1)
except Exception as ex:
message = template.format(type(ex).__name__, ex.args)
print(message)
self.dirname = dir
self.seperator_vertical = QVSeperationLine()
self.seperator_horizontal = QHSeperationLine()
self.initUI()
self.setWindowTitle("MainWindow")
self.overlay = Overlay(self.centralWidget())
self.available_cameras = QCameraInfo.availableCameras()
if not self.available_cameras:
pass #quit
self.select_camera(0)
def initUI(self):
self.homeUI()
def homeUI(self):
self.preview_widget = QWidget()
self.footer_widget = QWidget()
self.grid_widget = QWidget()
self.graph_widget = QWidget()
self.home = True
self.viewfinder = QCameraViewfinder()
self.viewfinder.show()
self.setCentralWidget(self.viewfinder)
self.cap = None # -capture <-> +cap
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout2 = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout = QVBoxLayout()
self.chartLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.image_label = QLabel()
self.image_label.setText("")
self.image_label.setObjectName("image_label")
self.image_label.setStyleSheet("QLabel { margin-right:4px; }")
self.temp = QLabel()
self.temp.setText("TEMPERATURE : ")
self.temp.setObjectName("temp")
self.temp.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp.setAlignment(QtCore.Qt.AlignCenter)
self.temp_reading = QLabel()
self.temp_reading.setText("READING...")
self.temp_reading.setObjectName("temp_reading")
self.temp_reading.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp_reading.setAlignment(QtCore.Qt.AlignCenter)
self.temp2 = QLabel()
self.temp2.setText("ROOM READING : ")
self.temp2.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
self.temp2.setObjectName("temp2")
#self.temp2.setAlignment(QtCore.Qt.AlignCenter)
self.temp2_reading = QLabel()
self.temp2_reading.setText("READING...")
self.temp2_reading.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp2_reading.setAlignment(QtCore.Qt.AlignCenter)
self.temp2_reading.setObjectName("temp2_reading")
self.image_label.setScaledContents(True)
self.matplotlibWidget = MatplotlibWidget(self)
self.threadSample = ThreadSample(self)
self.threadSample.newSample.connect(self.on_threadSample_newSample)
self.threadSample.finished.connect(self.on_threadSample_finished)
self.gridLayout = QGridLayout(self)
self.gridLayout.addWidget(self.temp, 0, 0, 1, 1)
self.gridLayout.addWidget(self.temp_reading, 0, 1, 1, 3)
self.gridLayout.addWidget(self.temp2, 2, 0, 1, 1)
self.gridLayout.addWidget(self.temp2_reading, 2, 1, 1, 3)
self.clock(self.gridLayout, 3, 0, 3, 3)
self.grid_widget.setLayout(self.gridLayout)
self.grid_widget.setMinimumHeight(250)
self.grid_widget.setMaximumHeight(250)
self.grid_widget.setMinimumWidth(600)
self.grid_widget.setMaximumWidth(600)
self.horizontalLayout.addWidget(self.image_label)
#self.horizontalLayout.addWidget(self.seperator_vertical)
self.horizontalLayout.addWidget(self.graph_widget)
self.preview_widget.setLayout(self.horizontalLayout)
self.preview_widget.setMinimumHeight(200)
self.preview_widget.setMaximumHeight(200)
self.preview_widget.setMinimumWidth(600)
self.preview_widget.setMaximumWidth(600)
# self.chartLayout.addWidget(self.matplotlibWidget)
# self.graph_widget.setLayout(self.chartLayout)
self.graph_widget.setMinimumHeight(250)
self.graph_widget.setMaximumHeight(250)
self.graph_widget.setMinimumWidth(250)
self.graph_widget.setMaximumWidth(250)
self.horizontalLayout2.addWidget(self.grid_widget)
# self.horizontalLayout2.addWidget(self.seperator_vertical)
#self.horizontalLayout2.addWidget(self.clock)
#self.clock(self.horizontalLayout2)
self.footer_widget.setLayout(self.horizontalLayout2)
self.footer_widget.setMinimumHeight(250)
self.footer_widget.setMaximumHeight(250)
self.footer_widget.setMinimumWidth(600)
self.footer_widget.setMaximumWidth(600)
self.verticalLayout.addWidget(self.preview_widget)
self.verticalLayout.addWidget(self.seperator_horizontal)
self.verticalLayout.addWidget(self.footer_widget)
#self.verticalLayout.addWidget(self.image_label2)
self.timer = QTimer(self, interval=5)
self.timer.timeout.connect(self.update_frame)
self._image_counter = 0
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
self.centralWidget().setLayout(self.verticalLayout)
self.start_webcam()
self.update_frame()
# self.setCentralWidget(self.scroll)
self.setGeometry(300, 300, 400, 700)
thread = Thread(target=self.read_temp)
thread.daemon = True
thread.start()
def select_camera(self, i):
self.camera = QCamera(self.available_cameras[i])
self.camera.setViewfinder(self.viewfinder)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.error.connect(
lambda: self.alert(self.camera.errorString()))
self.camera.start()
self.capture = QCameraImageCapture(self.camera)
self.capture.error.connect(lambda i, e, s: self.alert(s))
self.capture.imageCaptured.connect(lambda d, i: self.statusmessage(
"Image %04d captured" % self.save_seq))
self.current_camera_name = self.available_cameras[i].description()
self.save_seq = 0
def read_temp(self):
temp = []
while True:
self.ser.write(b'0x55,0xAA,5,1,4')
response = self.ser.readline()
print(str(response))
if 'body' in str(response):
temp.append(str(response))
#print("temp-"+str(response))
#print(temp)
elif 'Vbat' in str(response):
if len(temp) != 0:
temp[1] = temp[1].replace('b\'T body =', '')
temp[1] = temp[1].replace("\\r\\n'", '')
temp[0] = temp[0].replace('b\'T body =', '')
temp[0] = temp[0].replace("compensate\\r\\n'", '')
self.findFaces('-'.join(temp))
self.update_label(temp[0], temp[1], '12')
temp = []
time.sleep(1)
# start = time.clock()
# while True:
# if True:
# if True:
# temp.append(str(random.randint(0,100)))
# temp.append(str(random.randint(0,100)))
# self.overlay.show()
# self.findFaces('-'.join(temp))
# self.update_label(temp[0],temp[1],'12')
# self.overlay.hide()
# print("Done-"+ ' '.join(temp))
# temp = []
# time.sleep(1)
def statusmessage(self, msg):
self.statusBar().showMessage(msg)
def update_label(self, temp1, temp2, time):
print(temp1)
temp2 = self.getTemp(str(temp2))
temp1 = self.getTemp(str(temp1))
if temp2 >= 36.1 and temp2 <= 37.2:
pal = self.temp_reading.palette()
pal.setColor(QPalette.WindowText, QColor("green"))
self.temp_reading.setPalette(pal)
else:
pal = self.temp_reading.palette()
pal.setColor(QPalette.WindowText, QColor("red"))
self.temp_reading.setPalette(pal)
# if temp2>=36.1 and temp2<=37.2:
# pal = self.temp_reading.palette()
# pal.setColor(QPalette.WindowText, QColor("black"))
# self.temp2_reading.setPalette(pal)
# else:
# pal = self.temp_reading.palette()
# pal.setColor(QPalette.WindowText, QColor("black"))
# self.temp2_reading.setPalette(pal)
self.temp_reading.setText(str(temp2) + " °C")
self.temp2_reading.setText(str(temp1) + " °C")
#self.temp2_reading.setColor(QPalette.WindowText, QtGui.QColor("red"))
def getTemp(self, inp):
temp = re.findall(r"[-+]?\d*\.\d+|\d+", inp)
temp = ''.join(temp)
if temp == '':
return 0
else:
return float(temp)
def filter(self, text):
text = text.replace('bTbody', 'body')
text = text.replace('\'', '')
text = text.replace('\\r\n\'b\'Tbody', '-')
text = text.replace('\\r', '')
text = text.replace('\r', '')
text = text.replace('\\xa8', '')
text = text.replace('\\xa1\\xe6', '')
text = text.replace('\\n', '-')
text = text.replace(' ', '')
text = text.replace(', ', ',')
text = text.replace('=', '_')
text = text.replace(',', '-')
return text
def alert(self, s):
"""
Handle errors coming from QCamera dn QCameraImageCapture by displaying alerts.
"""
err = QErrorMessage(self)
err.showMessage(s)
@QtCore.pyqtSlot()
def start_webcam(self):
if self.cap is None:
self.cap = cv2.VideoCapture(0)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
self.timer.start()
def start_cam(self):
self.cap.open(0)
def stop_webcam(self):
self.cap.release()
def closeEvent(self, event):
print("closing PyQtTest")
self.cap.close()
@QtCore.pyqtSlot()
def update_frame(self):
if self.cap.isOpened():
ret, image = self.cap.read()
#self.face_detect(image,file_name)
simage = cv2.flip(image, 1)
self.displayImage(image, True)
def findFaces(self, file_name):
face_detect = True
while face_detect:
if self.cap.isOpened():
ret, frame = self.cap.read()
face_locations = fl(frame)
print("I found {} face(s) in this photograph.".format(
len(face_locations)))
#self.statusmessage("I found {} face(s) in this photograph.".format(len(face_locations)))
for face_location in face_locations:
face_detect = False
# Print the location of each face in this image
top, right, bottom, left = face_location
print(
"A face is located at pixel location Top: {}, Left: {}, Bottom: {}, Right: {}"
.format(top, left, bottom, right))
# ts = time.time()
# You can access the actual face itself like this:
face_image = frame[top - 100:bottom + 100,
left - 100:right + 100]
ts = datetime.now().strftime('%Y_%m_%d-%H_%M_%S')
cv2.imwrite(
os.path.abspath(
os.path.join(self.dirname,
(ts + '-' + file_name + '.jpg'))),
face_image)
self.storage.upload(self.dirname,
(ts + '-' + file_name + '.jpg'))
def face_detect(self, file_name):
face_locations = []
face_encodings = []
face_names = []
process_this_frame = True
i = 0
face_detect = True
# Resize frame of video to 1/4 size for faster face recognition processing
while face_detect:
ret, frame = self.cap.read()
#self.face_detect(image,file_name)
#simage = cv2.flip(image, 1)
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
# Only process every other frame of video to save time
if process_this_frame:
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(
rgb_small_frame)
face_encodings = face_recognition.face_encodings(
rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
face_detect = False
name = "Unknown"
cv2.imwrite(
os.path.abspath(
os.path.join(
self.dirname,
(datetime.today().strftime('%Y-%m-%d') + '-' +
file_name + '-' + str(++i) + '.png'))), frame)
#self.storage.upload(self.dirname,(datetime.today().strftime('%Y-%m-%d')+'-'+file_name+'-'+str(i)+'.png'))
i = i + 1
print("I see someone named {}!".format(name))
# # If a match was found in known_face_encodings, just use the first one.
# if True in matches:
# first_match_index = matches.index(True)
# name = known_face_names[first_match_index]
# Or instead, use the known face with the smallest distance to the new face
process_this_frame = not process_this_frame
@QtCore.pyqtSlot()
def capture_image(self):
if self.cap.isOpened():
flag, frame = self.cap.read()
timestamp = time.strftime("%d-%b-%Y-%H_%M_%S")
self.save_seq += 1
path = self.dirname #
if flag:
QtWidgets.QApplication.beep()
name = "my_image.jpg"
cv2.imwrite(
os.path.join(
self.dirname, "%s-%04d-%s.jpg" %
(self.current_camera_name, self.save_seq, timestamp)),
frame)
self.alert('Image Store Successfully.')
self._image_counter += 1
def displayImage(self, img, window=True):
qformat = QImage.Format_Indexed8
if len(img.shape) == 3:
if img.shape[2] == 4:
qformat = QImage.Format_RGBA8888
else:
qformat = QImage.Format_RGB888
outImage = QImage(img, img.shape[1], img.shape[0], img.strides[0],
qformat)
outImage = outImage.rgbSwapped()
if window:
self.image_label.setStyleSheet("""
QLabel {
height:300px !important;
}
""")
self.image_label.setPixmap(QPixmap.fromImage(outImage))
def clock(self, layout, row, col, row_span, col_span):
self.verticalLayoutClock = QVBoxLayout(self)
self.dateEdit = QDateEdit(self)
self.dateEdit.setDisplayFormat("MMM dd yyyy")
self.dateEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.dateEdit)
self.timeEdit = QTimeEdit(self)
self.timeEdit.setDisplayFormat("hh:mm:ss AP")
self.timeEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.timeEdit)
self.updateTime()
self.timer = QTimer(self)
self.timer.timeout.connect(self.updateTime)
self.timer.start(1000)
layout.addLayout(self.verticalLayoutClock, row, col, row_span,
col_span)
@QtCore.pyqtSlot(list)
def on_threadSample_newSample(self, sample):
self.matplotlibWidget.axis.plot(sample)
self.matplotlibWidget.canvas.draw()
@QtCore.pyqtSlot()
def on_threadSample_finished(self):
self.samples += 1
if self.samples <= 2:
self.threadSample.start()
@QtCore.pyqtSlot()
def on_pushButtonPlot_clicked(self):
self.samples = 0
self.matplotlibWidget.axis.clear()
self.threadSample.start()
def updateTime(self):
current = QtCore.QDateTime.currentDateTime()
self.dateEdit.setDate(current.date())
self.timeEdit.setTime(current.time())
class StartHandicapDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
self.time_format = 'hh:mm:ss'
self.setWindowTitle(_('Handicap start time'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.handicap_mode = QRadioButton(_('Handicap mode'))
self.reverse_mode = QRadioButton(_('Reverse mode'))
self.layout.addRow(self.handicap_mode)
self.layout.addRow(self.reverse_mode)
self.zero_time_label = QLabel(_('Start time'))
self.zero_time = QTimeEdit()
self.zero_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.zero_time_label, self.zero_time)
self.max_gap_label = QLabel(_('Max gap from leader'))
self.max_gap = QTimeEdit()
self.max_gap.setDisplayFormat(self.time_format)
self.layout.addRow(self.max_gap_label, self.max_gap)
self.second_start_time_label = QLabel(_('Start time for 2 group'))
self.second_time = QTimeEdit()
self.second_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.second_start_time_label, self.second_time)
self.interval_time_label = QLabel(_('Start interval'))
self.interval_time = QTimeEdit()
self.interval_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.interval_time_label, self.interval_time)
self.dsq_offset_label = QLabel(_('Offset after DSQ'))
self.dsq_offset = QTimeEdit()
self.dsq_offset.setDisplayFormat(self.time_format)
self.layout.addRow(self.dsq_offset_label, self.dsq_offset)
def mode_changed():
status = self.handicap_mode.isChecked()
self.max_gap.setEnabled(status)
self.second_time.setEnabled(status)
self.dsq_offset.setDisabled(status)
self.handicap_mode.toggled.connect(mode_changed)
self.reverse_mode.toggled.connect(mode_changed)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
logging.exception(e)
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.set_values()
self.show()
def set_values(self):
obj = race()
if obj.get_setting('handicap_mode', True):
self.handicap_mode.toggle()
else:
self.reverse_mode.toggle()
self.zero_time.setTime(
OTime(msec=obj.get_setting('handicap_start',
OTime(0, 11).to_msec())).to_time())
self.max_gap.setTime(
OTime(msec=obj.get_setting('handicap_max_gap',
OTime(0, 0, 30).to_msec())).to_time())
self.second_time.setTime(
OTime(msec=obj.get_setting('handicap_second_start',
OTime(0, 11, 30).to_msec())).to_time())
self.interval_time.setTime(
OTime(msec=obj.get_setting('handicap_interval',
OTime(0, 0, 1).to_msec())).to_time())
self.dsq_offset.setTime(
OTime(msec=obj.get_setting('handicap_dsq_offset',
OTime(0, 0, 10).to_msec())).to_time())
def apply_changes_impl(self):
obj = race()
obj.set_setting('handicap_mode', self.handicap_mode.isChecked())
obj.set_setting('handicap_start',
time_to_otime(self.zero_time.time()).to_msec())
obj.set_setting('handicap_max_gap',
time_to_otime(self.max_gap.time()).to_msec())
obj.set_setting('handicap_second_start',
time_to_otime(self.second_time.time()).to_msec())
obj.set_setting('handicap_interval',
time_to_otime(self.interval_time.time()).to_msec())
obj.set_setting('handicap_dsq_offset',
time_to_otime(self.dsq_offset.time()).to_msec())
if obj.get_setting('handicap_mode', True):
handicap_start_time()
else:
reverse_start_time()
GlobalAccess().get_main_window().refresh()
def __init__(self):
super().__init__()
self.setObjectName("MainWindow")
layout = QGridLayout()
w = QWidget()
self.setCentralWidget(w)
w.setLayout(layout)
ws = []
b = QPushButton("Open Question Small")
b.clicked.connect(self.open_question_small)
ws.append(b)
b = QPushButton("Open Question Large")
b.clicked.connect(self.open_question_large)
ws.append(b)
b = QPushButton("Open Error Small")
b.clicked.connect(self.open_error_small)
ws.append(b)
b = QPushButton("Open Error Large")
b.clicked.connect(self.open_error_large)
ws.append(b)
b = QPushButton("Open Info Small")
b.clicked.connect(self.open_info_small)
ws.append(b)
b = QPushButton("Open Info Large")
b.clicked.connect(self.open_info_large)
ws.append(b)
b = QPushButton("Open Get Text Small")
b.clicked.connect(self.open_get_text_small)
ws.append(b)
b = QPushButton("Open Get Text Large")
b.clicked.connect(self.open_get_text_large)
ws.append(b)
ws.append(QPushButton("Enabled"))
b = QPushButton("Disabled")
b.setDisabled(True)
ws.append(b)
le = QLineEdit()
le.setText("Normal")
ws.append(le)
le = QLineEdit()
le.setReadOnly(True)
le.setText("Read Only")
ws.append(le)
le = QLineEdit()
le.setDisabled(True)
le.setText("Disabled")
ws.append(le)
ws.append(QSpinBox())
sp = QSpinBox()
sp.setDisabled(True)
ws.append(sp)
ws.append(QTimeEdit())
te = QTimeEdit()
te.setDisabled(True)
ws.append(te)
cb = QComboBox()
cb.addItem("Item 1")
cb.addItem("Item 2")
cb.setView(QListView())
ws.append(cb)
cb = QComboBox()
cb.addItem("Item 1")
cb.addItem("Item 2")
cb.setDisabled(True)
ws.append(cb)
ws.append(QCheckBox("Normal"))
cb = QCheckBox("Disabled")
cb.setDisabled(True)
ws.append(cb)
with open("parsec/core/gui/rc/styles/main.css") as fd:
self.setStyleSheet(fd.read())
self.ensurePolished()
col = 0
for idx, w in enumerate(ws):
if idx % 3 == 0 and idx > 0:
col = 0
w.setToolTip("ToolTip example")
layout.addWidget(w, int(idx / 3), col)
col += 1
class QFrameSelect(QWidget):
frameSelectionChanged = pyqtSignal(int, QTime)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
layout = QVBoxLayout()
self.setLayout(layout)
self.slider = Slider(self)
self.slider.setOrientation(Qt.Horizontal)
self.slider.valueChanged.connect(self._handleSliderChange)
self.slider.setTickInterval(1)
layout.addWidget(self.slider)
hlayout = QHBoxLayout()
layout.addLayout(hlayout)
self.leftLabel = QLabel(self)
self.spinBox = QSpinBox(self)
self.spinBox.valueChanged.connect(self._handleSpinboxChange)
self.currentTime = QTimeEdit(self)
self.currentTime.setDisplayFormat("H:mm:ss.zzz")
self.currentTime.timeChanged.connect(self._handleTimeEditChange)
self.currentTime.editingFinished.connect(self._handleTimeEditFinished)
self.rightLabel = QLabel(self)
hlayout.addWidget(self.leftLabel)
hlayout.addStretch()
hlayout.addWidget(QLabel("Frame index:", self))
hlayout.addWidget(self.spinBox)
hlayout.addWidget(QLabel("Timestamp:", self))
hlayout.addWidget(self.currentTime)
hlayout.addStretch()
hlayout.addWidget(self.rightLabel)
self.setPtsTimeArray(None)
def setValue(self, n):
self.slider.setValue(n)
def setMinimum(self, n=0):
self.slider.setMinimum(n)
self.spinBox.setMinimum(n)
ms = int(self.pts_time[n] * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.setMinimumTime(QTime(h, m, s, ms))
self.leftLabel.setText(f"{n} ({h}:{m:02d}:{s:02d}.{ms:03d})")
def setMaximum(self, n=None):
if n is None:
n = len(self.pts_time) - 1
self.slider.setMaximum(n)
self.spinBox.setMaximum(n)
ms = int(self.pts_time[n] * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.setMaximumTime(QTime(h, m, s, ms))
self.rightLabel.setText(f"{n} ({h}:{m:02d}:{s:02d}.{ms:03d})")
def setStartEndVisible(self, value):
self.leftLabel.setHidden(not bool(value))
self.rightLabel.setHidden(not bool(value))
def setPtsTimeArray(self, pts_time=None):
self.pts_time = pts_time
if pts_time is not None:
N = len(pts_time)
self.setMinimum(0)
self.setMaximum(N - 1)
self.slider.setValue(0)
self.slider.setSnapValues(None)
self.slider.setDisabled(False)
self.spinBox.setDisabled(False)
self.currentTime.setDisabled(False)
else:
self.slider.setMinimum(0)
self.slider.setMaximum(0)
self.slider.setSnapValues(None)
self.slider.setDisabled(True)
self.spinBox.setDisabled(True)
self.currentTime.setDisabled(True)
def _handleSliderChange(self, n):
self.spinBox.blockSignals(True)
self.spinBox.setValue(n)
self.spinBox.blockSignals(False)
pts_time = self.pts_time[n]
ms = int(pts_time * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.blockSignals(True)
self.currentTime.setTime(QTime(h, m, s, ms))
self.currentTime.blockSignals(False)
self.frameSelectionChanged.emit(n, QTime(h, m, s, ms))
def _handleSpinboxChange(self, n):
self.slider.blockSignals(True)
self.slider.setValue(n)
self.slider.blockSignals(False)
pts_time = self.pts_time[n]
ms = int(pts_time * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.blockSignals(True)
self.currentTime.setTime(QTime(h, m, s, ms))
self.currentTime.blockSignals(False)
self.frameSelectionChanged.emit(n, QTime(h, m, s, ms))
def _handleTimeEditChange(self, t):
pts = t.msecsSinceStartOfDay() / 1000
try:
n = search(self.pts_time, pts + 0.0005, dir="-")
except IndexError:
n = 0
if n != self.slider.value():
self.slider.blockSignals(True)
self.slider.setValue(n)
self.slider.blockSignals(False)
self.spinBox.blockSignals(True)
self.spinBox.setValue(n)
self.spinBox.blockSignals(False)
pts_time = self.pts_time[n]
ms = int(pts_time * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.frameSelectionChanged.emit(n, QTime(h, m, s, ms))
def _handleTimeEditFinished(self):
t = self.currentTime.time()
pts = t.msecsSinceStartOfDay() / 1000
n = search(self.pts_time, pts + 0.0005, dir="-")
pts_time = self.pts_time[n]
ms = int(pts_time * 1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
T = QTime(h, m, s, ms)
if t != T:
self.currentTime.setTime(T)
class TimekeepingPropertiesDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
self.time_format = 'hh:mm:ss'
def exec(self):
self.init_ui()
return super().exec()
def init_ui(self):
# self.setFixedWidth(500)
self.setWindowTitle(_('Timekeeping settings'))
# self.setWindowIcon(QIcon(icon_dir('sportident.png')))
self.setSizeGripEnabled(False)
self.setModal(True)
self.tab_widget = QTabWidget()
# timekeeping tab
self.timekeeping_tab = QWidget()
self.tk_layout = QFormLayout()
self.label_zero_time = QLabel(_('Zero time'))
self.item_zero_time = QTimeEdit()
self.item_zero_time.setDisplayFormat("HH:mm")
self.item_zero_time.setMaximumSize(60, 20)
self.item_zero_time.setDisabled(True)
self.tk_layout.addRow(self.label_zero_time, self.item_zero_time)
self.label_si_port = QLabel(_('Available Ports'))
self.item_si_port = AdvComboBox()
self.item_si_port.addItems(SIReaderClient().get_ports())
self.tk_layout.addRow(self.label_si_port, self.item_si_port)
self.start_group_box = QGroupBox(_('Start time'))
self.start_layout = QFormLayout()
self.item_start_protocol = QRadioButton(_('From protocol'))
self.start_layout.addRow(self.item_start_protocol)
self.item_start_station = QRadioButton(_('Start station'))
self.start_layout.addRow(self.item_start_station)
self.item_start_cp = QRadioButton(_('Control point'))
self.item_start_cp_value = QSpinBox()
self.item_start_cp_value.setMaximumSize(60, 20)
self.start_layout.addRow(self.item_start_cp, self.item_start_cp_value)
self.item_start_gate = QRadioButton(_('Start gate'))
self.item_start_gate.setDisabled(True)
self.start_layout.addRow(self.item_start_gate)
self.start_group_box.setLayout(self.start_layout)
self.tk_layout.addRow(self.start_group_box)
self.finish_group_box = QGroupBox(_('Finish time'))
self.finish_layout = QFormLayout()
self.item_finish_station = QRadioButton(_('Finish station'))
self.finish_layout.addRow(self.item_finish_station)
self.item_finish_cp = QRadioButton(_('Control point'))
self.item_finish_cp_value = QSpinBox()
self.item_finish_cp_value.setMinimum(-1)
self.item_finish_cp_value.setMaximumSize(60, 20)
self.finish_layout.addRow(self.item_finish_cp, self.item_finish_cp_value)
self.item_finish_beam = QRadioButton(_('Light beam'))
self.item_finish_beam.setDisabled(True)
self.finish_layout.addRow(self.item_finish_beam)
self.finish_group_box.setLayout(self.finish_layout)
self.tk_layout.addRow(self.finish_group_box)
self.chip_reading_box = QGroupBox(_('Assigning a chip when reading'))
self.chip_reading_layout = QFormLayout()
self.chip_reading_off = QRadioButton(_('Off'))
self.chip_reading_layout.addRow(self.chip_reading_off)
self.chip_reading_unknown = QRadioButton(_('Only unknown members'))
self.chip_reading_layout.addRow(self.chip_reading_unknown)
self.chip_reading_always = QRadioButton(_('Always'))
self.chip_reading_layout.addRow(self.chip_reading_always)
self.chip_reading_box.setLayout(self.chip_reading_layout)
self.tk_layout.addRow(self.chip_reading_box)
self.assignment_mode = QCheckBox(_('Assignment mode'))
self.assignment_mode.stateChanged.connect(self.on_assignment_mode)
self.tk_layout.addRow(self.assignment_mode)
self.timekeeping_tab.setLayout(self.tk_layout)
# result processing tab
self.result_proc_tab = QWidget()
self.result_proc_layout = QFormLayout()
self.rp_time_radio = QRadioButton(_('by time'))
self.result_proc_layout.addRow(self.rp_time_radio)
self.rp_scores_radio = QRadioButton(_('by scores'))
self.rp_scores_radio.setDisabled(True) # TODO
self.result_proc_layout.addRow(self.rp_scores_radio)
self.rp_scores_group = QGroupBox()
self.rp_scores_group.setDisabled(True) # TODO
self.rp_scores_layout = QFormLayout(self.rp_scores_group)
self.rp_rogain_scores_radio = QRadioButton(_('rogain scores'))
self.rp_scores_layout.addRow(self.rp_rogain_scores_radio)
self.rp_fixed_scores_radio = QRadioButton(_('fixed scores'))
self.rp_fixed_scores_edit = QSpinBox()
self.rp_fixed_scores_edit.setMaximumWidth(50)
self.rp_scores_layout.addRow(self.rp_fixed_scores_radio, self.rp_fixed_scores_edit)
self.rp_scores_minute_penalty_label = QLabel(_('minute penalty'))
self.rp_scores_minute_penalty_edit = QSpinBox()
self.rp_scores_minute_penalty_edit.setMaximumWidth(50)
self.rp_scores_layout.addRow(self.rp_scores_minute_penalty_label, self.rp_scores_minute_penalty_edit)
self.result_proc_layout.addRow(self.rp_scores_group)
self.result_proc_tab.setLayout(self.result_proc_layout)
# marked route settings
self.marked_route_tab = QWidget()
self.mr_layout = QFormLayout()
self.mr_off_radio = QRadioButton(_('no penalty'))
self.mr_layout.addRow(self.mr_off_radio)
self.mr_time_radio = QRadioButton(_('penalty time'))
self.mr_time_edit = QTimeEdit()
self.mr_time_edit.setDisplayFormat(self.time_format)
self.mr_layout.addRow(self.mr_time_radio, self.mr_time_edit)
self.mr_laps_radio = QRadioButton(_('penalty laps'))
self.mr_layout.addRow(self.mr_laps_radio)
self.mr_counting_lap_check = QCheckBox(_('counting lap'))
self.mr_counting_lap_check.setDisabled(True) # TODO
self.mr_layout.addRow(self.mr_counting_lap_check)
self.mr_lap_station_check = QCheckBox(_('lap station'))
self.mr_lap_station_check.setDisabled(True) # TODO
self.mr_lap_station_edit = QSpinBox()
self.mr_lap_station_edit.setMaximumWidth(50)
self.mr_layout.addRow(self.mr_lap_station_check, self.mr_lap_station_edit)
self.marked_route_tab.setLayout(self.mr_layout)
# scores
"""
Scores
[ x ] scores array
40, 37, 35, 33, ... 2, 1 [ Edit ]
[ ] scores formula
1000 - 1000 * result / leader [ Edit ]
"""
self.scores_tab = QWidget()
self.scores_layout = QFormLayout()
self.scores_off = QRadioButton(_('scores off'))
self.scores_array = QRadioButton(_('scores array'))
self.scores_array_edit = QLineEdit()
self.scores_formula = QRadioButton(_('scores formula'))
self.scores_formula_edit = QLineEdit()
self.scores_formula_hint = QLabel(_('scores formula hint'))
self.scores_formula_hint.setWordWrap(True)
self.scores_layout.addRow(self.scores_off)
self.scores_layout.addRow(self.scores_array)
self.scores_layout.addRow(self.scores_array_edit)
self.scores_layout.addRow(self.scores_formula)
self.scores_layout.addRow(self.scores_formula_edit)
self.scores_layout.addRow(self.scores_formula_hint)
self.scores_tab.setLayout(self.scores_layout)
# time settings
self.time_settings_tab = QWidget()
self.time_settings_layout = QFormLayout()
self.time_settings_accuracy_label = QLabel(_('Accuracy'))
self.time_settings_accuracy_edit = QSpinBox()
self.time_settings_accuracy_edit.setMaximumWidth(50)
self.time_settings_accuracy_edit.setMaximum(3)
self.time_settings_layout.addRow(self.time_settings_accuracy_label, self.time_settings_accuracy_edit)
self.time_settings_format = QGroupBox()
self.time_settings_format.setTitle(_('Format of competitions'))
self.time_settings_format_less = QRadioButton(_('< 24'))
self.time_settings_format_more = QRadioButton(_('> 24'))
self.time_settings_format_layout = QFormLayout()
self.time_settings_format_layout.addRow(self.time_settings_format_less)
self.time_settings_format_layout.addRow(self.time_settings_format_more)
self.time_settings_format.setLayout(self.time_settings_format_layout)
self.time_settings_layout.addRow(self.time_settings_format)
self.time_settings_tab.setLayout(self.time_settings_layout)
self.tab_widget.addTab(self.timekeeping_tab, _('SPORTident (Sportiduino, ...) settings'))
self.tab_widget.addTab(self.result_proc_tab, _('Result processing'))
self.tab_widget.addTab(self.scores_tab, _('Scores'))
self.tab_widget.addTab(self.marked_route_tab, _('Penalty calculation'))
self.tab_widget.addTab(self.time_settings_tab, _('Time settings'))
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout = QFormLayout(self)
self.layout.addRow(self.tab_widget)
self.layout.addRow(button_box)
self.set_values_from_model()
self.show()
def on_assignment_mode(self):
mode = False
if self.assignment_mode.isChecked():
mode = True
self.start_group_box.setDisabled(mode)
self.finish_group_box.setDisabled(mode)
self.chip_reading_box.setDisabled(mode)
def set_values_from_model(self):
cur_race = race()
zero_time = cur_race.get_setting('system_zero_time', (8, 0, 0))
start_source = cur_race.get_setting('system_start_source', 'protocol')
start_cp_number = cur_race.get_setting('system_start_cp_number', 31)
finish_source = cur_race.get_setting('system_finish_source', 'station')
finish_cp_number = cur_race.get_setting('system_finish_cp_number', 90)
assign_chip_reading = cur_race.get_setting('system_assign_chip_reading', 'off')
assignment_mode = cur_race.get_setting('system_assignment_mode', False)
si_port = cur_race.get_setting('system_port', '')
self.item_zero_time.setTime(QTime(zero_time[0], zero_time[1]))
self.item_si_port.setCurrentText(si_port)
if start_source == 'protocol':
self.item_start_protocol.setChecked(True)
elif start_source == 'station':
self.item_start_station.setChecked(True)
elif start_source == 'cp':
self.item_start_cp.setChecked(True)
elif start_source == 'gate':
self.item_start_gate.setChecked(True)
self.item_start_cp_value.setValue(start_cp_number)
if finish_source == 'station':
self.item_finish_station.setChecked(True)
elif finish_source == 'cp':
self.item_finish_cp.setChecked(True)
elif finish_source == 'beam':
self.item_finish_beam.setChecked(True)
self.item_finish_cp_value.setValue(finish_cp_number)
if assign_chip_reading == 'off':
self.chip_reading_off.setChecked(True)
elif assign_chip_reading == 'only_unknown_members':
self.chip_reading_unknown.setChecked(True)
elif assign_chip_reading == 'always':
self.chip_reading_always.setChecked(True)
self.assignment_mode.setChecked(assignment_mode)
# result processing
obj = cur_race
rp_mode = obj.get_setting('result_processing_mode', 'time')
rp_score_mode = obj.get_setting('result_processing_score_mode', 'rogain')
rp_fixed_scores_value = obj.get_setting('result_processing_fixed_score_value', 1)
rp_scores_minute_penalty = obj.get_setting('result_processing_scores_minute_penalty', 1)
if rp_mode == 'time':
self.rp_time_radio.setChecked(True)
else:
self.rp_scores_radio.setChecked(True)
if rp_score_mode == 'rogain':
self.rp_rogain_scores_radio.setChecked(True)
else:
self.rp_fixed_scores_radio.setChecked(True)
self.rp_fixed_scores_edit.setValue(rp_fixed_scores_value)
self.rp_scores_minute_penalty_edit.setValue(rp_scores_minute_penalty)
# penalty calculation
mr_mode = obj.get_setting('marked_route_mode', 'off')
mr_penalty_time = OTime(msec=obj.get_setting('marked_route_penalty_time', 60000))
mr_if_counting_lap = obj.get_setting('marked_route_if_counting_lap', True)
mr_if_station_check = obj.get_setting('marked_route_if_station_check', False)
mr_station_code = obj.get_setting('marked_route_station_code', 80)
if mr_mode == 'off':
self.mr_off_radio.setChecked(True)
elif mr_mode == 'time':
self.mr_time_radio.setChecked(True)
else:
self.mr_laps_radio.setChecked(True)
self.mr_time_edit.setTime(mr_penalty_time.to_time())
self.mr_counting_lap_check.setChecked(mr_if_counting_lap)
self.mr_lap_station_check.setChecked(mr_if_station_check)
self.mr_lap_station_edit.setValue(mr_station_code)
# score settings
scores_mode = obj.get_setting('scores_mode', 'off')
scores_array = obj.get_setting('scores_array', '40,37,35,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,'
'16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1')
scores_formula = obj.get_setting('scores_formula', '200 - 100 * time / leader')
if scores_mode == 'off':
self.scores_off.setChecked(True)
elif scores_mode == 'array':
self.scores_array.setChecked(True)
elif scores_mode == 'formula':
self.scores_formula.setChecked(True)
self.scores_array_edit.setText(scores_array)
self.scores_formula_edit.setText(scores_formula)
# time settings
time_accuracy = obj.get_setting('time_accuracy', 0)
time_format_24 = obj.get_setting('time_format_24', 'less24')
self.time_settings_accuracy_edit.setValue(time_accuracy)
if time_format_24 == 'less24':
self.time_settings_format_less.setChecked(True)
elif time_format_24 == 'more24':
self.time_settings_format_more.setChecked(True)
def apply_changes_impl(self):
obj = race()
start_source = 'protocol'
if self.item_start_station.isChecked():
start_source = 'station'
elif self.item_start_cp.isChecked():
start_source = 'cp'
elif self.item_start_gate.isChecked():
start_source = 'gate'
finish_source = 'station'
if self.item_finish_cp.isChecked():
finish_source = 'cp'
elif self.item_finish_beam.isChecked():
finish_source = 'beam'
assign_chip_reading = 'off'
if self.chip_reading_unknown.isChecked():
assign_chip_reading = 'only_unknown_members'
elif self.chip_reading_always.isChecked():
assign_chip_reading = 'always'
start_cp_number = self.item_start_cp_value.value()
finish_cp_number = self.item_finish_cp_value.value()
old_start_cp_number = obj.get_setting('system_start_cp_number', 31)
old_finish_cp_number = obj.get_setting('system_finish_cp_number', 90)
if old_start_cp_number != start_cp_number or old_finish_cp_number != finish_cp_number:
race().clear_results()
obj.set_setting('system_port', self.item_si_port.currentText())
obj.set_setting('system_start_source', start_source)
obj.set_setting('system_finish_source', finish_source)
obj.set_setting('system_start_cp_number', start_cp_number)
obj.set_setting('system_finish_cp_number', finish_cp_number)
obj.set_setting('system_assign_chip_reading', assign_chip_reading)
obj.set_setting('system_assignment_mode', self.assignment_mode.isChecked())
# result processing
rp_mode = 'time'
if self.rp_scores_radio.isChecked():
rp_mode = 'scores'
rp_score_mode = 'rogain'
if self.rp_fixed_scores_radio.isChecked():
rp_score_mode = 'fixed'
rp_fixed_scores_value = self.rp_fixed_scores_edit.value()
rp_scores_minute_penalty = self.rp_scores_minute_penalty_edit.value()
obj.set_setting('result_processing_mode', rp_mode)
obj.set_setting('result_processing_score_mode', rp_score_mode)
obj.set_setting('result_processing_fixed_score_value', rp_fixed_scores_value)
obj.set_setting('result_processing_scores_minute_penalty', rp_scores_minute_penalty)
# marked route
mr_mode = 'off'
if self.mr_laps_radio.isChecked():
mr_mode = 'laps'
if self.mr_time_radio.isChecked():
mr_mode = 'time'
obj.set_setting('marked_route_mode', mr_mode)
mr_penalty_time = time_to_otime(self.mr_time_edit.time()).to_msec()
mr_if_counting_lap = self.mr_counting_lap_check.isChecked()
mr_if_station_check = self.mr_lap_station_check.isChecked()
mr_station_code = self.mr_lap_station_edit.value()
obj.set_setting('marked_route_mode', mr_mode)
obj.set_setting('marked_route_penalty_time', mr_penalty_time)
obj.set_setting('marked_route_if_counting_lap', mr_if_counting_lap)
obj.set_setting('marked_route_if_station_check', mr_if_station_check)
obj.set_setting('marked_route_station_code', mr_station_code)
# score settings
scores_mode = 'off'
if self.scores_array.isChecked():
scores_mode = 'array'
elif self.scores_formula.isChecked():
scores_mode = 'formula'
scores_array = self.scores_array_edit.text()
scores_formula = self.scores_formula_edit.text()
obj.set_setting('scores_mode', scores_mode)
obj.set_setting('scores_array', scores_array)
obj.set_setting('scores_formula', scores_formula)
# time settings
time_accuracy = self.time_settings_accuracy_edit.value()
time_format_24 = 'less24'
if self.time_settings_format_more.isChecked():
time_format_24 = 'more24'
obj.set_setting('time_accuracy', time_accuracy)
obj.set_setting('time_format_24', time_format_24)
ResultCalculation(race()).process_results()
GlobalAccess().get_main_window().refresh()
class ResultEditDialog(QDialog):
def __init__(self, result, is_new=False):
super().__init__(GlobalAccess().get_main_window())
assert (isinstance(result, Result))
self.current_object = result
self.is_new = is_new
self.time_format = 'hh:mm:ss'
time_accuracy = race().get_setting('time_accuracy', 0)
if time_accuracy:
self.time_format = 'hh:mm:ss.zzz'
def exec(self):
self.init_ui()
self.set_values_from_model()
return super().exec()
def init_ui(self):
self.setWindowTitle(_('Result'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.item_created_at = QTimeEdit()
self.item_created_at.setDisplayFormat(self.time_format)
self.item_created_at.setReadOnly(True)
self.item_card_number = QSpinBox()
self.item_card_number.setMaximum(9999999)
self.item_bib = QSpinBox()
self.item_bib.setMaximum(Limit.BIB)
self.item_bib.valueChanged.connect(self.show_person_info)
self.label_person_info = QLabel('')
self.item_days = QSpinBox()
self.item_days.setMaximum(365)
self.item_finish = QTimeEdit()
self.item_finish.setDisplayFormat(self.time_format)
self.item_start = QTimeEdit()
self.item_start.setDisplayFormat(self.time_format)
self.item_result = QLineEdit()
self.item_result.setEnabled(False)
self.item_penalty = QTimeEdit()
self.item_penalty.setDisplayFormat(self.time_format)
self.item_penalty_laps = QSpinBox()
self.item_penalty_laps.setMaximum(1000000)
self.radio_ok = QRadioButton(_('OK'))
self.radio_ok.setChecked(True)
self.radio_dns = QRadioButton(_('DNS'))
self.radio_dnf = QRadioButton(_('DNF'))
self.radio_overtime = QRadioButton(_('Overtime'))
self.radio_dsq = QRadioButton(_('DSQ'))
self.item_status_comment = AdvComboBox()
self.item_status_comment.setMaximumWidth(250)
self.item_status_comment.view().setMinimumWidth(650)
self.item_status_comment.addItems(StatusComments().get_all())
more24 = race().get_setting('time_format_24', 'less24') == 'more24'
self.splits = SplitsText(more24=more24)
self.layout.addRow(QLabel(_('Created at')), self.item_created_at)
if self.current_object.is_punch():
self.layout.addRow(QLabel(_('Card')), self.item_card_number)
self.layout.addRow(QLabel(_('Bib')), self.item_bib)
self.layout.addRow(QLabel(''), self.label_person_info)
if more24:
self.layout.addRow(QLabel(_('Days')), self.item_days)
self.layout.addRow(QLabel(_('Start')), self.item_start)
self.layout.addRow(QLabel(_('Finish')), self.item_finish)
self.layout.addRow(QLabel(_('Penalty')), self.item_penalty)
self.layout.addRow(QLabel(_('Penalty legs')), self.item_penalty_laps)
self.layout.addRow(QLabel(_('Result')), self.item_result)
self.layout.addRow(self.radio_ok)
self.layout.addRow(self.radio_dns)
self.layout.addRow(self.radio_dnf)
self.layout.addRow(self.radio_overtime)
self.layout.addRow(self.radio_dsq, self.item_status_comment)
if self.current_object.is_punch():
start_source = race().get_setting('system_start_source',
'protocol')
finish_source = race().get_setting('system_finish_source',
'station')
if start_source == 'protocol' or start_source == 'cp':
self.item_start.setDisabled(True)
if finish_source == 'cp':
self.item_finish.setDisabled(True)
self.layout.addRow(self.splits.widget)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
if self.current_object.person:
button_person = button_box.addButton(_('Entry properties'),
QDialogButtonBox.ActionRole)
button_person.clicked.connect(self.open_person)
self.layout.addRow(button_box)
self.show()
self.item_bib.setFocus()
def show_person_info(self):
bib = self.item_bib.value()
self.label_person_info.setText('')
self.button_ok.setEnabled(True)
if bib:
person = find(race().persons, bib=bib)
if person:
info = person.full_name
if person.group:
info = '{}\n{}: {}'.format(info, _('Group'),
person.group.name)
if person.card_number:
info = '{}\n{}: {}'.format(info, _('Card'),
person.card_number)
self.label_person_info.setText(info)
else:
self.label_person_info.setText(_('not found'))
self.button_ok.setDisabled(True)
def set_values_from_model(self):
if self.current_object.is_punch():
if self.current_object.card_number:
self.item_card_number.setValue(
int(self.current_object.card_number))
self.splits.splits(self.current_object.splits)
self.splits.show()
if self.current_object.created_at:
self.item_created_at.setTime(
time_to_qtime(
datetime.fromtimestamp(self.current_object.created_at)))
if self.current_object.finish_time:
self.item_finish.setTime(
time_to_qtime(self.current_object.finish_time))
if self.current_object.start_time is not None:
self.item_start.setTime(
time_to_qtime(self.current_object.start_time))
if self.current_object.finish_time:
self.item_result.setText(str(self.current_object.get_result()))
if self.current_object.penalty_time is not None:
self.item_penalty.setTime(
time_to_qtime(self.current_object.penalty_time))
if self.current_object.penalty_laps:
self.item_penalty_laps.setValue(self.current_object.penalty_laps)
if self.current_object.person:
self.item_bib.setValue(self.current_object.person.bib)
self.item_days.setValue(self.current_object.days)
if self.current_object.is_status_ok():
self.radio_ok.setChecked(True)
elif self.current_object.status == ResultStatus.DISQUALIFIED:
self.radio_dsq.setChecked(True)
elif self.current_object.status == ResultStatus.OVERTIME:
self.radio_overtime.setChecked(True)
elif self.current_object.status == ResultStatus.DID_NOT_FINISH:
self.radio_dnf.setChecked(True)
elif self.current_object.status == ResultStatus.DID_NOT_START:
self.radio_dns.setChecked(True)
self.item_status_comment.setCurrentText(
self.current_object.status_comment)
self.item_bib.selectAll()
def open_person(self):
try:
EntryEditDialog(self.current_object.person).exec()
except Exception as e:
logging.error(str(e))
def apply_changes_impl(self):
result = self.current_object
if self.is_new:
race().results.insert(0, result)
if result.is_punch():
if result.card_number != self.item_card_number.value():
result.card_number = self.item_card_number.value()
new_splits = self.splits.splits()
if len(result.splits) == len(new_splits):
for i, split in enumerate(result.splits):
if split != new_splits[i]:
break
result.splits = new_splits
time_ = time_to_otime(self.item_finish.time())
if result.finish_time != time_:
result.finish_time = time_
time_ = time_to_otime(self.item_start.time())
if result.start_time != time_:
result.start_time = time_
time_ = time_to_otime(self.item_penalty.time())
if result.penalty_time != time_:
result.penalty_time = time_
if result.penalty_laps != self.item_penalty_laps.value():
result.penalty_laps = self.item_penalty_laps.value()
cur_bib = -1
new_bib = self.item_bib.value()
if result.person:
cur_bib = result.person.bib
if new_bib == 0:
if result.person and result.is_punch():
if result.person.card_number == result.card_number:
result.person.card_number = 0
result.person = None
elif cur_bib != new_bib:
new_person = find(race().persons, bib=new_bib)
if new_person is not None:
assert isinstance(new_person, Person)
if result.person:
if result.is_punch():
result.person.card_number = 0
result.person = new_person
if result.is_punch():
race().person_card_number(result.person,
result.card_number)
GlobalAccess().get_main_window().get_result_table().model(
).init_cache()
if self.item_days.value() != result.days:
result.days = self.item_days.value()
status = ResultStatus.NONE
if self.radio_ok.isChecked():
status = ResultStatus.OK
elif self.radio_dsq.isChecked():
status = ResultStatus.DISQUALIFIED
elif self.radio_overtime.isChecked():
status = ResultStatus.OVERTIME
elif self.radio_dnf.isChecked():
status = ResultStatus.DID_NOT_FINISH
elif self.radio_dns.isChecked():
status = ResultStatus.DID_NOT_START
if result.status != status:
result.status = status
status = StatusComments().remove_hint(
self.item_status_comment.currentText())
if result.status_comment != status:
result.status_comment = status
if result.is_punch():
result.clear()
try:
ResultChecker.checking(result)
ResultChecker.calculate_penalty(result)
if result.person and result.person.group:
GroupSplits(race(), result.person.group).generate(True)
except ResultCheckerException as e:
logging.error(str(e))
ResultCalculation(race()).process_results()
GlobalAccess().get_main_window().refresh()
Teamwork().send(result.to_dict())
