def main():
parser = argparse.ArgumentParser(
description='Recognize faces from an image file')
parser.add_argument('input', type=str, help='Input file')
parser.add_argument('--output',
'-o',
type=str,
help='Output file (default: none)')
args = parser.parse_args()
img = cv2.imread(str(Path(args.input)))
faces = recognize_face(img)
print('found faces:', len(faces))
draw_rectangles(img, faces)
if args.output:
print('Saving image ...')
cv2.imwrite(args.output, img)
app = QApplication([])
window = ImageArea()
window.setCVImage(img)
window.show()
app.exit(app.exec_())
def get_reference_dict(calibration_file_path=False):
if not calibration_file_path:
app = QApplication(sys.argv)
file_dialog = QFileDialog()
file_dialog.setWindowFlags(Qt.WindowStaysOnTopHint)
file_path = file_dialog.getOpenFileName(None,
"FAMES REF FILE",
filter="*.cdf")[0]
file_dialog.close()
app.exit()
else:
file_path = calibration_file_path
if not file_path: return None
else:
gcms_ref_obj = get_gcms(file_path)
sql_obj = start_sql_from_file()
rt_ri_pairs = get_rt_ri_pairs(gcms_ref_obj, sql_obj=sql_obj)
# !!!!!! READ !!!!! use the previous two lines if db/pnnl_lowres_gcms_compounds.sqlite does not exist
# and comment the next line
#rt_ri_pairs = get_rt_ri_pairs(gcms_ref_obj)
return rt_ri_pairs, file_path
def create_app():
app = QApplication([])
widget = MainWidget()
widget.resize(1200, 800)
widget.show()
app.exit(app.exec_())
class GUIApplication:
def __init__(self, app):
self.started = False
self.app = app
self.args = app.args
self.config = app.config
self.library = app.library
self.workplace = app.workplace
self.analyzer = app.analyzer
logging.debug("qt_argv: %r", self.args.qt_argv)
self.qapp = QApplication(self.args.qt_argv)
self.qapp.setApplicationName("Sample Drawer")
for path in RESOURCE_FILENAMES:
if os.path.exists(path):
logger.debug("Loading resources from %r", path)
QResource.registerResource(path)
QIcon.setThemeSearchPaths(QIcon.themeSearchPaths() +
["/home/jajcus/git/sampledrawer/icons"])
logger.debug("Icon search path: %r", QIcon.themeSearchPaths())
QIcon.setFallbackSearchPaths([":icons/"] + QIcon.fallbackSearchPaths())
logger.debug("Icon fallback path: %r", QIcon.fallbackSearchPaths())
logger.debug("Theme name %r", QIcon.themeName())
logger.debug("Fallback theme name: %r", QIcon.fallbackThemeName())
self.qapp.setWindowIcon(QIcon(":icons/sampledrawer.svg"))
def start(self):
try:
self.audio_driver = get_audio_driver(self.args)
except AudioDriverError as err:
logger.error("Audio driver initialization error: %s", err)
return 1
self.log_window = LogWindow(self)
self.main_window = MainWindow(self)
self.main_window.show()
signal_handler = SignalHandler()
signal_handler.activate()
self.qapp.aboutToQuit.connect(signal_handler.deactivate)
self.started = True
try:
return self.qapp.exec_()
finally:
self.started = False
def exit(self, code):
if self.qapp and self.started:
self.qapp.exit(code)
else:
self.app.exit(code)
def requestStarted(self, job: QWebEngineUrlRequestJob) -> None:
webUiOrigin = QUrl(SCHEMENAME + ":")
GET: QByteArray = QByteArray(b"GET")
POST: QByteArray = QByteArray(b"POST")
method = job.requestMethod()
url = job.requestUrl()
initiator = job.initiator()
if method == GET and url == WebUiHandler.aboutUrl:
f = QFile(":/about.html", job)
f.open(QIODevice.ReadOnly)
job.reply(b"text/html", f)
elif (method == POST and url == WebUiHandler.aboutUrl
and initiator == webUiOrigin):
job.fail(QWebEngineUrlRequestJob.RequestAborted)
QApplication.exit()
else:
job.fail(QWebEngineUrlRequestJob.UrlNotFound)
class App(QObject):
def __init__(self, args):
super(App, self).__init__()
QCoreApplication.setOrganizationName('Dynart')
QCoreApplication.setApplicationName('NodeEditor')
self._qApp = QApplication(args)
self._qApp.setStyle(Style())
self._mainWindow = MainWindow(self)
self._mainWindow.show()
def run(self):
settings = QSettings()
self._mainWindow.restoreGeometry(settings.value('mainWindowGeometry'))
self._mainWindow.restoreState(settings.value('mainWindowState'))
return self._qApp.exec_()
def exit(self, returnCode=0):
settings = QSettings()
settings.setValue('mainWindowGeometry', self._mainWindow.saveGeometry())
settings.setValue('mainWindowState', self._mainWindow.saveState())
self._qApp.exit(returnCode)
def main():
parser = argparse.ArgumentParser(
description='Recognize faces from an video file')
parser.add_argument('-i',
'--input',
type=str,
help='Input file (default: Webcam on your computer)')
parser.add_argument('-o',
'--output',
type=str,
help='Output file (default: None)')
args = parser.parse_args()
if args.input:
video = args.input
else:
video = 0
app = QApplication([])
window = VideoArea(video, args.output)
window.show()
app.exit(app.exec_())
def thoat(self):
QApplication.exit()
def slot_exit(self):
QApplication.exit(0)
class GUI(Thread):
''' render the board items and write descrete inputs when button is pushed. '''
die = False
def __init__(self, context):
Thread.__init__(self)
self.app = None
self.bulb = None
self.context = context[0]
def clickedButton1(self):
log.info('clicked')
''' descrete input function seems to be 2 '''
address = 0x00
old_values = self.context.getValues(READ_INPUT, address, count=1)
log.info('old values: ' + str(old_values))
values = [1 for v in old_values]
log.info('clickedButton1 reg 2 addr 0 new values: ' + str(values))
self.context.setValues(READ_INPUT, address, values)
time.sleep(1)
self.context.setValues(READ_INPUT, address, old_values)
def clickedButton2(self):
log.info('clicked')
''' descrete input function seems to be 2 '''
address = 0x01
old_values = self.context.getValues(READ_INPUT, address)
log.info('old values: ' + str(old_values))
values = [1 for v in old_values]
log.info('clickedButton2 reg %d addr 0x%x new values: %s' %
(READ_INPUT, address, str(values)))
self.context.setValues(READ_INPUT, address, values)
time.sleep(1)
self.context.setValues(READ_INPUT, address, old_values)
def run(self):
self.app = QApplication(sys.argv)
win = QWidget()
vbox = QVBoxLayout()
button1 = QPushButton('Button 1')
button2 = QPushButton('Button 2')
button1.clicked.connect(self.clickedButton1)
button2.clicked.connect(self.clickedButton2)
self.bulb = QLabel()
self.bulb.setText("Bulb: OFF")
vbox.addWidget(button1)
vbox.addWidget(button2)
vbox.addWidget(self.bulb)
win.setLayout(vbox)
win.setWindowTitle('Physical Board')
win.resize(200, 200)
win.show()
try:
self.app.exec_()
except KeyboardInterrupt:
log.info('GUI FOUND interrupt')
self.endMe()
def setBulb(self, is_on):
if self.bulb is not None:
if is_on:
self.bulb.setText("Bulb: ON")
self.bulb.setStyleSheet('background-color: yellow')
else:
self.bulb.setText("Bulb: OFF")
self.bulb.setStyleSheet('background-color: white')
def endMe(self):
self.app.exit()
exit(0)
class pyWordArt:
def __init__(self,
text="WordArt Test",
style=15,
size=100,
noOpenGL=False):
self.Styles = {
'outline': 0,
'up': 1,
'arc': 2,
'squeeze': 3,
'inverted-arc': 4,
'basic-stack': 5,
'italic-outline': 6,
'slate': 7,
'mauve': 8,
'graydient': 9,
'red-blue': 10,
'brown-stack': 11,
'radial': 12,
'purple': 13,
'green-marble': 14,
'rainbow': 15,
'aqua': 16,
'texture-stack': 17,
'paper-bag': 18,
'sunset': 19,
'tilt': 20,
'blues': 21,
'yellow-dash': 22,
'green-stack': 23,
'chrome': 24,
'marble-slab': 25,
'gray-block': 26,
'superhero': 27,
'horizon': 28,
'stack-3d': 29
}
self.noOpenGL = noOpenGL
#better safe than sorry
if self.noOpenGL == False and sys.platform != "win32" and sys.platform != "darwin":
if not self.__X_is_running():
self.noOpenGL = True
arglist = [sys.argv[0], "--disable-web-security"]
if self.noOpenGL:
arglist.append("-platform")
arglist.append("minimal")
self.__app = QApplication(arglist)
#Required properties:
self.text = text
self.size = size
self.style = style
#Optional properties:
self.transparentBackground = False
self.canvasWidth = 1754 #3508
self.canvasHeight = 1240 #2480
self.debug = False
def WordArt(self, wordartText, wordartStyle, wordartSize):
self.text = wordartText
self.style = wordartStyle
self.size = wordartSize
def toHTML(self, wordartText, wordartStyle, wordartSize):
srcfolder = os.path.abspath(os.path.dirname(__file__))
myhtml = "<!DOCTYPE html>"
myhtml = myhtml + "<html>"
myhtml = myhtml + "<head>"
myhtml = myhtml + "<title>CSS3 WordArt</title>"
myhtml = myhtml + "<link href=\"file://" + srcfolder + "/css3wordart/css/style.css\" rel=\"stylesheet\" type=\"text/css\" />"
myhtml = myhtml + "<script src=\"file://" + srcfolder + "/css3wordart/js/object-observe-lite.js\"></script>"
myhtml = myhtml + "<script src=\"file://" + srcfolder + "/css3wordart/js/wordart.js\"></script>"
myhtml = myhtml + "</head>"
myhtml = myhtml + "<body>"
myhtml = myhtml + "<input type=\"hidden\" id=\"canvasWidth\" name=\"canvasWidth\" value=\"" + str(
self.canvasWidth) + "\">"
myhtml = myhtml + "<input type=\"hidden\" id=\"canvasHeight\" name=\"canvasHeight\" value=\"" + str(
self.canvasHeight) + "\">"
myhtml = myhtml + "<input type=\"hidden\" id=\"wordart-style\" name=\"wordart-style\" value=\"" + str(
wordartStyle) + "\">"
myhtml = myhtml + "<input type=\"hidden\" id=\"wordart-size\" name=\"wordart-size\" value=\"" + str(
wordartSize) + "\">"
myhtml = myhtml + "<section class=\"background\">"
myhtml = myhtml + "<template id=\"bgWordart\">"
myhtml = myhtml + "<div class=\"wordart\">"
myhtml = myhtml + "<center><span class=\"text\" id=\"wordart-text\" name=\"wordart-text\" data-text=\"" + wordartText + "\">" + wordartText + "</span></center>"
myhtml = myhtml + "</div>"
myhtml = myhtml + "</template>"
myhtml = myhtml + "</section>"
myhtml = myhtml + "</body>"
myhtml = myhtml + "</html>"
return myhtml
def toFile(self, filename):
self.imgName = filename
if not bool(
self.imgName.endswith(".png") or self.imgName.endswith(".jpg")
or self.imgName.endswith(".jpeg") or
self.imgName.endswith(".gif") or self.imgName.endswith(".tif")
or self.imgName.endswith(".tiff")
or self.imgName.endswith(".bmp")):
self.imgName = self.imgName + ".png"
self.__render()
return self.imgName
def toBase64(self):
self.__buffer = QtCore.QBuffer()
self.__buffer.open(QtCore.QBuffer.ReadWrite)
self.__render()
b64 = self.__buffer.data().toBase64().data()
return b64
def toBufferIO(self):
b64 = self.toBase64()
return io.BytesIO(base64.decodebytes(b64))
def __render(self):
self.__view = QtWebEngineWidgets.QWebEngineView()
self.__view.setFixedSize(self.canvasWidth, self.canvasHeight)
self.__view.loadFinished.connect(self.__grabimage)
myhtml = self.toHTML(self.text, self.style, self.size)
self.__view.setHtml(myhtml)
if not self.debug:
self.__view.setAttribute(QtCore.Qt.WA_DontShowOnScreen, True)
self.__view.setAttribute(QtCore.Qt.WA_ShowWithoutActivating, True)
self.__view.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self.__view.setAttribute(QtCore.Qt.WA_AlwaysStackOnTop, True)
self.__view.show()
self.__app.exec_()
def __grabimage(self):
if sys.platform == "win32":
QApplication.processEvents()
if self.debug:
test = input("Press return to continue or Ctrl+C to stop")
pixmap = self.__view.grab()
image = self.__cropImage(pixmap.toImage(), self.transparentBackground)
useBuffer = True
try:
if not self.__buffer.isOpen():
useBuffer = False
except:
useBuffer = False
if useBuffer:
image.save(self.__buffer, "PNG")
time.sleep(0.1)
self.__buffer.close()
else:
image.save(self.imgName)
while not os.path.isfile(self.imgName):
time.sleep(0.1)
time.sleep(
0.1
) #sometimes we need a little bit more just to be sure the file has actually been written
self.__view.hide()
self.__app.exit()
def __cropImage(self, origimage, transparentBackground=False):
maxX = 0
minX = origimage.width()
maxY = 0
minY = origimage.height()
exclusionColor = QtGui.QColor(255, 255, 255, 255)
for x in range(origimage.width()):
for y in range(origimage.height()):
if QtGui.QColor.fromRgb(origimage.pixel(x,
y)) != exclusionColor:
if x < minX:
minX = x
if x > maxX:
maxX = x
if y < minY:
minY = y
if y > maxY:
maxY = y
if minX > maxX or minY > maxY:
myimage = origimage
else:
myimage = origimage.copy(minX, minY, maxX - minX, maxY - minY)
if transparentBackground:
newimage = QtGui.QImage(myimage.width(), myimage.height(),
QtGui.QImage.Format_ARGB32)
for x in range(myimage.width()):
for y in range(myimage.height()):
tmpcolor = QtGui.QColor.fromRgb(myimage.pixel(x, y))
if tmpcolor == exclusionColor:
newimage.setPixelColor(x, y, QtGui.QColor(0, 0, 0, 0))
else:
newimage.setPixelColor(x, y, tmpcolor)
myimage = newimage
return myimage
def __X_is_running(self):
try:
#thanks to : https://stackoverflow.com/questions/1027894/detect-if-x11-is-available-python, it's much more clean than my original idea
p = Popen(["xset", "-q"], stdout=PIPE, stderr=PIPE)
p.communicate()
return p.returncode == 0
except:
return False
def demo(self, dirName, wordartSize=100):
if not os.path.isdir(dirName):
print("Not a folder")
return
for elem in self.Styles:
self.WordArt("WordArt Test", self.Styles[elem], wordartSize)
self.toFile(dirName + "/demo-" + elem + ".png")
rewards.append(reward)
if done:
episode_rewards.append(np.sum(rewards))
episode_length.append(t)
episode_critic_loss.append(np.sum(critics))
print(
"episode: {}, reward: {}, total length: {}, entropy {:.2f}"
.format(i_episode, np.sum(rewards), t, overall_entropy))
break
advantage = torch.stack(advantages)
# update actor critic
entropys = torch.stack(entropys)
log_probs = torch.stack(log_probs)
critic_loss = 0.5 * advantage.pow(2).sum()
actor_loss = (-log_probs * advantage.detach()).sum()
ac_loss = actor_loss + critic_loss - 0.01 * entropys.sum()
episode_actor_loss.append(critic_loss.detach().numpy())
episode_total_loss.append(ac_loss.detach().numpy())
episode_entropy.append(entropys.mean())
# print("episode loss {:.2f} \n".format(ac_loss))
ac_optimizer.zero_grad()
ac_loss.backward()
torch.nn.utils.clip_grad_norm_(actor_critic.parameters(), 1)
ac_optimizer.step()
app.exec_()
sys.exit(app.exit())
def _exitButtonClicked(self):
QApplication.exit(0)
from PySide2.QtWidgets import QApplication, QFrame
import sys
import time
from classes.main_window import MainWindow
if __name__ == "__main__":
app = QApplication(sys.argv)
window = MainWindow()
window.resize(480, 130)
window.show()
app.exec_()
app.exit()
def exit_app(self,checked):
QApplication.exit(-1234)
class Application:
def __init__(self):
self.title = u'Tracks detection'
# Настройки
self.settings = Settings()
def application_init(self):
'''Инициализация Qt приложения'''
# Создание приложение
self.qapp = QApplication(sys.argv)
self.__app_working_status = True
# Установка локлизатора
translator = QTranslator(self.qapp)
translator.load('lang/tr_ru', os.path.dirname(__file__))
self.qapp.installTranslator(translator)
self.mainDialog = MainDialog(self, self.title)
self.mainDialog.closeApp.connect(self.__finalize_before_quit)
self.controls = {
'step': ['X', 'Y', 'Z', 'A'],
'servo': ['B', 'C'],
'pins': {
'P1': [],
'P2': ['UV', 'VIS']
}
}
self.mainDialog.show()
self.project_init()
self.gui_init()
self.communication_init()
sys.exit(self.qapp.exec_())
def __finalize_before_quit(self):
self.__app_working_status = False
if self.grbl.connection: self.grbl.connection.close()
if self.communication_thread: self.communication_thread.join()
self.qapp.exit()
def retuenicon(self, name):
return QIcon(
QPixmap(
os.path.normpath(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'', name + '.png'))))
def project_init(self):
self.project = Project('New')
def async_sleep(self, sleep):
for i in range(sleep):
time.sleep(1)
if not self.__app_working_status: break
def __connection_worker(self):
while self.__app_working_status:
status = self.__current_conacion_procedure()
if status: break
if status:
self.__current_conacion_procedure = self.grbl.getStatus
else:
self.__current_conacion_procedure = self.__auto_seach__
self.async_sleep(5)
self.cnc_indicator.setStatus(status)
def communication_init(self):
self.grbl = GRBL(HOST=self.settings.grblip)
self.__current_conacion_procedure = self.__auto_seach__
self.communication_thread = threading.Thread(
target=self.__connection_worker)
self.communication_thread.setDaemon(True)
self.communication_thread.start()
def gui_init(self):
pref_menu = menu_item(u'Preferences')
ref_menu = menu_item(u'Reference')
gen_menu = menu_item(u'Device')
gen_menu.addChildren(menu_item(u'GRBL', self.showGrblDialog))
file_menu = menu_item(self.qapp.tr(u'File'))
file_menu.addChildren(menu_item(u'New', self.newProject),
menu_item(u'Open', self.openProject),
menu_item(u'Import...', self.openFile),
menu_item(u'Save', self.saveProject),
menu_item(u'Exit', self.qapp.exit))
pref_menu.addChildren(gen_menu, menu_item(u'Settings'))
ref_menu.addChildren(menu_item(u'Help'),
menu_item(u'About', self.showAbout))
self.mainDialog.addMenuItems(file_menu, pref_menu, ref_menu)
self.cnc_indicator = work_indicator(u'CNC')
self.mainDialog.addStatusObj(self.cnc_indicator)
self.progressBar = QProgressBar()
self.progressBar.setTextVisible(True)
self.progressBar.setAlignment(Qt.AlignCenter)
self.progressBar.minimum = 1
self.progressBar.maximum = 100
self.mainDialog.addPermanentStatusObj(self.progressBar)
'''Инициализациия таблицы содержания'''
treeDock = QDockWidget(self.qapp.tr(u'Project tree'), self.mainDialog)
treeDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.mainDialog.addDockWidget(Qt.LeftDockWidgetArea, treeDock)
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree = ProjectTree(self, self.mainnodes)
self.project_tree.doubleClicked.connect(self.on_tree_clicked)
treeDock.setWidget(self.project_tree)
'''Инициализациия центра'''
jog = JogWidget(app=self.qapp,
axies=self.controls,
pinAcions=self.pinAcions,
motorActions=self.send_to_grbl)
self.mainDialog.addToCenter(jog)
jog.raise_()
def send_to_grbl(self, text, send_type):
if len(text):
self.grbl.send_task(text, send_type)
def pinAcions(self, status, pin):
task = 'M62 {pin}'.format(pin=pin) if status else 'M63 {pin}'.format(
pin=pin)
self.grbl.send_task(task, SENDTYPE.IDLE)
def setProgress(self, step, steps):
value = step / float(len(steps)) * 100.
indx = int(ceil(step - 1))
text = self.qapp.tr(steps[indx])
self.progressBar.setFormat("{0} - {1}%".format(text, round(value, 0)))
self.progressBar.setValue(value)
self.qapp.processEvents()
def on_tree_clicked(self, index):
item = self.project_tree.selectedIndexes()[0]
if self.project.current_sample != item.model().itemFromIndex(
index).obj:
self.project.current_sample = item.model().itemFromIndex(index).obj
self.refresh()
def newProject(self):
self.mainDialog.PreparedArea.clear()
self.mainDialog.ThroughArea.clear()
self.mainDialog.BacklightArea.clear()
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree.setMainNodes(self.mainnodes)
self.project = Project('TEMP')
self.refresh()
def openProject(self):
fileName, _ = QFileDialog.getOpenFileName(
self.mainDialog, self.qapp.tr("Load project"), ".\\",
self.qapp.tr("Project file (*.tpr)"))
infile = open(fileName, 'rb')
self.project = pickle.load(infile)
infile.close()
self.mainDialog.PreparedArea.clear()
self.mainDialog.ThroughArea.clear()
self.mainDialog.BacklightArea.clear()
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree.setMainNodes(self.mainnodes)
self.refresh()
def saveProject(self):
fileName, _ = QFileDialog.getSaveFileName(
self.mainDialog, self.qapp.tr("Save project"), ".\\",
self.qapp.tr("Project file (*.tpr)"))
outfile = open(fileName, "wb")
pickle.dump(self.project, outfile)
outfile.close()
def draw_tree(self):
target = self.mainnodes[0]
children = target.children()
samples_in_tree = []
for sample in self.project.samples.get_sorted_by_id():
if len(children) > 0:
samples_in_tree = [node.obj for node in children]
if sample not in samples_in_tree:
target.addChild(Node(sample))
self.project_tree.refresh()
def openFile(self):
path_to_file, _ = QFileDialog.getOpenFileName(
self.mainDialog, self.qapp.tr("Load Image"),
self.qapp.tr(u".\example_imgs"), self.qapp.tr("Images (*.jpg)"))
# path_to_file, _ = QFileDialog.getOpenFileName(self.mainDialog, self.app.tr("Load Image"), self.app.tr("~/Desktop/"), self.app.tr("Images (*.jpg)"))
# Определяем тип файла на просвет или на подсветку
tools.processing(path_to_file, self.project, self.separator,
self.segmentation, self.counter, self.setProgress)
self.refresh()
def refresh(self):
self.draw_tree()
self.fill_table()
self.updete_viewers()
def fill_table(self):
data = []
sample = self.project.current_sample
if not sample:
data = [['', '', '']]
self.mainDialog.tablemodel.setData(data)
return
for track in sample.tracks.get_sorted():
data.append([str(track.id), str(track.count), str(track.area)])
self.mainDialog.tablemodel.setData(data)
self.mainDialog.table.resizeRowsToContents()
self.mainDialog.table.resizeColumnsToContents()
count = round(
np.sum([track.count
for track in sample.tracks.get_sorted_by_id()]), 2)
general_area = round(
np.sum([track.area for track in sample.tracks.get_sorted_by_id()]),
2)
self.mainDialog.infolabel.setText('''
<p align="center">General tracks count<br>{tracks_count}</p>
<p align="center">General tracks area (%)<br>{general_area}</p>
'''.format(tracks_count=count,
general_area=general_area))
def draw_objects(self, viewer, sample):
for track in sample.tracks.get_sorted():
viewer.add_rect(track.left, track.rigth, track.top, track.bottom)
viewer.add_Polygon(track.contour, track.left, track.top)
text = 'Count: {tracks_count}\nArea (%): {general_area}'.format(
tracks_count=track.count, general_area=track.area)
viewer.add_Text(text, track.left, track.top)
def updete_viewers(self):
sample = self.project.current_sample
if not sample:
return
self.mainDialog.ThroughArea.load_image(sample.through)
self.mainDialog.BacklightArea.load_image(sample.backlight)
self.mainDialog.PreparedArea.load_image(sample.prepared)
self.draw_objects(self.mainDialog.ThroughArea, sample)
self.draw_objects(self.mainDialog.BacklightArea, sample)
self.draw_objects(self.mainDialog.PreparedArea, sample)
def __connect_to_grbl__(self):
'''Функция подключения к CNC сканера, которая передается в настройки станка'''
status = self.grbl.connect()
if not status: return
self.cnc_indicator.setStatus(-1)
self.grbl.reset_alarm()
self.cnc_indicator.setStatus(status)
return status
def __check_ip__(self, ip):
status = False
test_grbl = GRBL(HOST=self.settings.grblip)
test_grbl.setHost(ip)
try:
status = test_grbl.connect(check=False)
test_grbl.connection.close()
except OSError:
pass
return ip if status else None
def __auto_seach__(self, property=None):
'''Функция авто поиска IP станка
property нужен, чтобы вернуть результат в inputField окна настроек
'''
if self.grbl.connection: self.grbl.connection.close()
devices = [device for device in os.popen('arp -a')]
ip_candidates = [
re.findall(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b", device)[0]
for device in devices if
len(re.findall(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",
device)) != 0
]
if self.settings.grblip in ip_candidates:
ip_candidates.remove(self.settings.grblip)
ip_candidates.insert(0, self.settings.grblip)
pool = ThreadPool(4)
results = pool.map(self.__check_ip__, ip_candidates)
index = np.where(results != None)[0][0]
if not results[index]:
# print(self.qapp.tr('There is not devices in current net'))
return
pool.close()
pool.join()
self.grbl.setHost(results[index])
self.__connect_to_grbl__()
if property:
property.setText(
results[index]
) # property нужен, чтобы вернуть результат в inputField
self.settings.grblip = results[index]
self.settings.write()
print(self.qapp.tr('Connected to') + ' {ip}'.format(ip=results[index]))
return True
def showAbout(self):
about = about_dialog(self)
about.open()
def showGrblDialog(self):
dialog = grblDialog(self,
connection_func=self.__connect_to_grbl__,
auto_seach_func=self.__auto_seach__)
dialog.execute(self.settings)
def reboot_app(self,checked):
QApplication.exit(mainwindow.EXIT_CODE_REBOOT)
while 1:
#print("thread")
self.camera.movie()
if self.camera.last_frame is not np.zeros((1, 1)):
#print("coucou")
self.image_camera = self.camera.last_frame[1]
#print(self.image_camera)
#print(self.image_camera)
height, width, channel = self.image_camera.shape
bytesPerLine = 3 * width
self.image = QImage(self.image_camera.data, width, height,
bytesPerLine,
QImage.Format_RGB888).rgbSwapped()
#print(self.image)
#self.painter.drawImage(0,0,self.image)
self.changePixmap.emit(self.image)
def stop(self):
#print("coucou")
self.terminate()
if __name__ == '__main__':
app = QApplication([])
C = Camera("http://192.168.1.62:8000/stream.mjpg")
C.initialize()
window = camera_view(C)
window.show()
app.exit(app.exec_())
def exit_app(self):
self.saveNotes()
QApplication.exit()
