def testLoadSettings(self):
settings = Settings()
settings.load('testSettings.ini')
notepads = settings.getNotepads()
self.assertEqual(2, len(notepads))
self.assertEqual('SampleWiki', notepads[0]['name'])
def mark(cls, look, displayname=None):
"""
Create xplanet marker based on observation
"""
key1 = str(look.wave.time.tt)
key2 = look.planet.origname
if key2 in Settings().locationstorage:
if key1 in Settings().locationstorage[key2]:
l1 = Settings().locationstorage[key2][key1]
# print("found")
else:
l1 = cls.calculate_lat_long(look.wave.time, look)
tmp = Settings().locationstorage[key2]
tmp.update({key1: l1})
Settings().locationstorage[key2] = tmp
else:
l1 = cls.calculate_lat_long(look.wave.time, look)
Settings().locationstorage[key2] = {key1: l1}
if displayname is None:
displayname = look.planet.name
return '{} {} "{}" {}'.format(str(l1[0]),
str(l1[1]),
displayname,
look.planet.color)
def pole(cls, look):
"""
Create xplanet pole as arc based on observation
"""
key1 = str(look.wave.time.tt)
key2 = look.planet.origname
if key2 in Settings().locationstorage:
if key1 in Settings().locationstorage[key2]:
l1 = Settings().locationstorage[key2][key1]
else:
l1 = cls.calculate_lat_long(look.wave.time, look)
tmp = Settings().locationstorage[key2]
tmp.update({key1: l1})
Settings().locationstorage[key2] = tmp
else:
l1 = cls.calculate_lat_long(look.wave.time, look)
Settings().locationstorage[key2] = {key1: l1}
l2 = Settings().midpoint
return '{} {} {} {} {}'.format(str(l1[0]),
str(l1[1]),
str(l2[0]),
str(l2[1]),
look.planet.color + " spacing=0.5")
def checkForUpdate(self):
update = 0
settings = Settings(os.getcwd() + '/' +"wlc_load.db") # i coded myself into a corner
while True:
if update < settings.get("lastUpdate"):
#send data to client
self.broadCast_Msg("Hello....smells like success")
time.sleep(2)
def uploadFile(file, resultCallbackFunction=printLink, progressCallbackFunction=printProgressToCLI, file_number = 0, semaphore = BoundedSemaphore(2), username="", password=""):
rs = Rapidshare_com(file, resultCallbackFunction, progressCallbackFunction, file_number)
from Settings import Settings
set = Settings()
if set.getUseRSPassword():
username,password = set.getRSCredentials()
rs.upload(semaphore, username, password)
del username
del password
def getUploader(file):
preferredUploaders = Settings().getPreferredUploaders()
extension = file.split('.')[-1].lower()
filetype = __getFiletype(extension)
if filetype in preferredUploaders.keys():
prefferedUploader = preferredUploaders[filetype]
else:
prefferedUploader = preferredUploaders["*"]
return getPluginByHostingName(prefferedUploader)
def test_phases(self):
'''
python3 -m unittest TestRun.TestRun.test_phases
'''
settings = Settings()
settings.setValue('XOphases', True)
rpt = ConsoleStreamReporter()
ctx = RunnerContext.RunnerContext(rpt, X64CodeGenContext(), settings)
ctx.run(self.cu)
def showNotification_(self, sender):
result = bool(self.chbShowNotification.state())
Settings.set("showNotification", result)
self.stprNotificationTime.setEnabled_(result)
self.edtNotificationTime.setEnabled_(result)
self.stprNotificationRepeatTime.setEnabled_(result)
self.edtNotificationRepeatTime.setEnabled_(result)
self.chbSoundOnNotification.setEnabled_(result)
self.btnPreviewPopup.setEnabled_(result)
def testPageSequence(self):
settings = Settings()
settings.load('testSettings.ini')
npDef = settings.getNotepads()[0]
self.assertEqual('SampleWiki', npDef['name'])
notepad = LocalNotepad(npDef)
self.assertEqual('SampleWiki', notepad.getName())
pageId = notepad.getNextPageId()
def projectChange_(self, sender):
"""Project changed event"""
if self.pbtnProject.titleOfSelectedItem():
self.cbxInput.removeAllItems()
self.cbxInput.addItemsWithObjectValues_(Projects.getAutocomleteList(
self.pbtnProject.titleOfSelectedItem(), SlackingAutocompletes.get()))
if sender:
Settings.set("selectedProject", unicode(self.pbtnProject.titleOfSelectedItem()))
Settings.sync()
def start(self, tray):
startDB = DB();
settings = Settings(startDB);
settings = settings.currentSettings();
FeedBox.FeedBox.setTheme(settings['theme']);
if(settings['startMinimalized']):
tray.minimalization();
if(settings['startup']):
self.updateAllFeeds();
def __init__(self) :
self.videos = dict()
self.services = dict()
self.locSettings = Settings('location')
self.storageSettings = Settings('storage')
if not os.path.exists(self.thumbnailDir()) :
os.mkdir(self.thumbnailDir())
if not os.path.exists(self.videoDir()) :
os.mkdir(self.videoDir())
class GameState:
#update game round i -> The number of the current round
#update game this_piece_type s -> The type of the piece that has just spawned on the field
#update game next_piece_type s -> The type of the piece that will spawn the next round
#update game this_piece_position i,i -> The starting position in the field for the current piece (top left corner of the piece bounding box)
def __init__(self):
self.round = 0
self.this_piece_type = 'n'
self.next_piece_type = 'n'
self.this_piece_position = {"x":1 , "y":2}
self.players = {"me":PlayerState(), "opponent":PlayerState()}
self.settings = Settings()
def parseSettingsMessage(self, parts):
self.settings.parseSetting(parts)
def parseGameMessage(self, parts):
if parts[0] == "game":
gameStateMessage = parts[1]
if gameStateMessage== 'round':
#update game round i
self.round = int(parts[2])
elif gameStateMessage == 'this_piece_type':
#update game this_piece_type s
self.this_piece_type = parts[2]
elif gameStateMessage == 'next_piece_type':
#update game next_piece_type s
self.next_piece_type = parts[2]
elif gameStateMessage == 'this_piece_position':
#update game this_piece_position i,i
position = parts[2].split(',')
self.this_piece_position["x"] = int(position[0])
self.this_piece_position["y"] = int(position[1])
else:
stderr.write('Unknown gameStateMessage: %s\n' % (parts[1]))
stderr.flush()
elif parts[0] == self.settings.bots["me"]:
self.players["me"].parsePlayerState(parts[1:])
elif parts[0] == self.settings.bots["opponent"]:
self.players["opponent"].parsePlayerState(parts[1:])
else:
stderr.write('Unknown gameStateMessage: %s\n' % (parts[0]))
stderr.flush()
def showStartHelpMessage(self):
"""Show alert with help message"""
alert = NSAlert.alloc().init()
alert.addButtonWithTitle_('OK')
alert.setMessageText_("Congrats, you started your working day!")
alert.setInformativeText_("Now start doing your working activity (e.g reading mail). "
"When you finish with your activity go back to MacTimeLog and type it in. "
"If your activity is slacking, use 2 asterisks (**) at the end of the activity's name.")
alert.setShowsSuppressionButton_(True)
alert.runModal()
if alert.suppressionButton().state() == NSOnState:
Settings.set("showHelpMessageOnStart", False)
Settings.sync()
def __init__(self):
self.round = 0
self.this_piece_type = 'n'
self.next_piece_type = 'n'
self.this_piece_position = {"x":1 , "y":2}
self.players = {"me":PlayerState(), "opponent":PlayerState()}
self.settings = Settings()
def __init__(self):
self._conn = Connection(FileStorage(Settings.get("projectsDataPath")))
self._data = self._conn.get_root()
if not len(self._data.keys()):
self._data["Default"] = PersistentDict(autocomplete=PersistentDict())
self.sync()
def leftSeconds(self):
"""Return time left to work"""
res = Settings.get("workDayLength") - self.spentSeconds
if res < 0:
return 0
else:
return res
def __init__(self, parent=None):
super(MainApp, self).__init__(parent)
self.setupUi(self)
self.makeSysTrayActions()
self.makeTrayIcon()
self.systrayIcon.messageClicked.connect(self.messageClicked)
self.systrayIcon.activated.connect(self.iconActivated)
self.systray_text_list = []
self.setIcon()
self.systrayIcon.show()
self.feed_reader = FeedReader()
self.active_filter = None
self.exclusive_filters = None
self.settings = Settings()
self.settings.load_settings()
self.statusbar.showMessage('Feeds tracked: ' + str(len(self.settings.uri_list)))
self.actionQuit.triggered.connect(QtGui.qApp.quit)
self.actionSettings.triggered.connect(self._slotSettings)
self.actionFilters.triggered.connect(self._slotFilters)
self.pushRefreshButton.clicked.connect(self._slotRefresh)
self.listWidgetRss.itemClicked.connect(self._slotItemClicked)
self.settings_dialogue = SettingsDialogue(self.settings, parent=self)
self.filter_dialogue = FilterDialogue(self.settings, parent=self)
self.refresh_timer = QTimer()
self.refresh_timer.timeout.connect(self._slotRefresh)
if self.settings.refresh_time != 0:
self.refresh_timer.start(self.settings.refresh_time * 60 * 1000)
self.alert_timer = QTimer()
self.alert_timer.timeout.connect(self._slotAlert)
if self.settings.alert_time != 0:
self.alert_timer.start(self.settings.alert_time * 60 * 1000)
self._slotRefresh()
def initControls(self):
"""Init basic controls"""
self.outputArea.setString_("")
self.tasks = Tasks()
if Settings.get("showWorkTill"):
self.workTillBox.setHidden_(False)
else:
self.workTillBox.setHidden_(True)
self.pbtnProject.removeAllItems()
self.pbtnProject.addItemsWithTitles_(Projects.get())
self.pbtnProject.selectItemWithTitle_(Settings.get("selectedProject"))
self.projectChange_(None)
self.fillTasks()
self.scrollToEnd()
def __init__(self, reporter, codeGenContext, settings = None):
self.expSymbolTable = expressionActionSymbolTable
self.expSymbolTable.clear()
self.kindSymbolTable = kindSymbolTable
self.kindSymbolTable.clear()
self.settings = Settings() if not settings else settings
self.codeGenContext = codeGenContext
self.architectureContext = codeGenContext.architectureContext
self.reporter = reporter
# init
self.phases = PhaseList(self._internalPhases())
def markPosition(self, event):
wFactor, hFactor = Settings.getOutputLabelFactors()
if self.drawState == WorkingWindow.STATE_NONE:
self.clickedPos = (int(event.x * wFactor), int(event.y * hFactor))
self.drawState = WorkingWindow.STATE_CLICK
self.stateLabel.configure(text=("Frame {} / {} - Wfsp!".format(self.currentFrame, len(self.frames))))
elif self.drawState == WorkingWindow.STATE_CLICK:
cv2.rectangle(self.labels[self.currentFrame], self.clickedPos, (int(event.x * wFactor), int(event.y * hFactor)), (255,255,255), -1)
self.drawState = WorkingWindow.STATE_NONE
self.showNext()
def formatTaskString(date, task, projectName, spentSeconds, taskType):
"""Format task string"""
if taskType == "work":
color = NSColor.blackColor()
elif taskType == "slack":
color = NSColor.grayColor()
else:
color = NSColor.colorWithCalibratedRed_green_blue_alpha_(.72,.72,.72, 1)
if spentSeconds is None: # Start of the day
taskString = "Your working day started on %s \n" % date.strftime("%c")
return taskString, color
else:
dtStr = ""
if Settings.get("showDateTime"):
dtStr = " " + date.strftime(str(Settings.get("logDateTimeFormat")))
project = ""
if projectName != "" and projectName != "Default" and taskType == "work":
project = "%s %s " % (projectName, Settings.get("projectSeparator"))
return "%s%s >> %s%s \n" % (secToTimeStr(spentSeconds), dtStr, project, task), color
class SettingsDialog(QDialog) :
def __init__(self, parent = None) :
QDialog.__init__(self, parent)
layout = QVBoxLayout()
self.settings = Settings()
self.edits = dict()
for key in Settings.values.keys():
layout.addLayout(self.createSettingField(key))
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
self.setLayout(layout)
def createSettingField(self, key) :
layout = QHBoxLayout()
layout.addWidget(QLabel(key))
value = Settings.values[key]
edit = QLineEdit(str(value))
if value == True or value == False :
edit = QCheckBox()
if value :
edit.setCheckState(Qt.Checked)
elif isinstance(value, int) :
edit.setValidator(QIntValidator())
elif isinstance(value, float) :
edit.setValidator(QDoubleValidator())
self.edits[key] = edit
layout.addWidget(edit)
return layout
def accept(self) :
value = Settings.values[key]
for key in self.keys :
if isinstance(value, int) :
self.settings.set(key, int(edit.text()))
elif isinstance(value, float) :
self.settings.set(key, float(edit.text()))
elif isinstance(value, bool) :
self.settings.set(key, edit.checkState() == Qt.Checked)
else :
self.settings.set(key, edit.text())
self.setVisible(False)
def reject(self) :
self.setVisible(False)
def btnDonePress_(self, sender):
"""On done button press"""
if self.tasks.dayStarted():
if self.cbxInput.stringValue().strip():
taskName = self.cbxInput.stringValue()
self.appendTask(*fh.formatTaskString(*self.tasks.add(taskName, self.pbtnProject.titleOfSelectedItem())))
self.readCounters()
self.cbxInput.setStringValue_("")
self.scrollToEnd()
if Tasks.taskType(taskName) == "work":
Projects.addAutocomplete(self.pbtnProject.titleOfSelectedItem(), taskName)
else:
SlackingAutocompletes.add(taskName)
self.cbxInput.addItemWithObjectValue_(taskName)
else:
if Settings.get("showHelpMessageOnStart"):
self.showStartHelpMessage()
taskName = Settings.get("startPlaceholder")
self.appendTask(*fh.formatTaskString(*self.tasks.add(taskName)))
self.initDoneButton()
def __init__(self, app):
QMainWindow.__init__(self, None)
self.l.debug('Initializing MainWindow ...')
self.setWindowTitle('MynPad')
app.setWindowIcon(QIcon(':/icons/mynpad.png'))
if os.name == 'nt':
# On Windows, make sure to use a unique Application User Model Id, otherwise
# Windows shows the default python icon in the taskbar
# see http://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7
myappid = 'afester.mynpad'
import ctypes; ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
self.theApplication = app
app.aboutToQuit.connect(self.saveState)
# read the local configuration file
iniPath = 'mynpad.ini'
if not os.path.exists(iniPath):
iniPath = os.path.join(expanduser("~"), iniPath)
self.settings = Settings(iniPath)
self.settings.load()
# Set up the menu bar
menuBar = QMenuBar(self)
exitAction = QAction("Exit", self, triggered=self.theApplication.exit)
fileMenu = menuBar.addMenu("&File")
fileMenu.addAction(exitAction)
aboutAction = QAction("About ...", self, triggered = self.handleAbout)
helpMenu = menuBar.addMenu("&Help")
helpMenu.addAction(aboutAction)
self.setMenuBar(menuBar)
# Setup the status bar
self.statusBar = QStatusBar()
self.statusBar.showMessage("Ready.")
self.setStatusBar(self.statusBar)
self.mainWidget = CentralWidget(self, self.settings)
self.mainWidget.updateWindowTitle.connect(self.updateWindowTitle)
self.setCentralWidget(self.mainWidget)
# Reset main window size and position
pos = self.settings.getMainWindowPos()
self.move(pos.x(), pos.y())
size = self.settings.getMainWindowSize()
self.resize(size)
# initialize the browser tree (add the top nodes and expand the saved path)
self.mainWidget.browserWidget.initialize()
def __init__(self, caller=None):
self._settings_class = Settings()
self._settings_dict = self._settings_class.getSettings()
self.__parent = caller
gtk.glade.bindtextdomain(translationsDomainName, translationsDirName)
gtk.glade.textdomain(translationsDomainName)
gladefile = "settings.glade"
self.__wTree = gtk.glade.XML(gladefile)
self.__window = self.__wTree.get_widget("Settings")
self.__optipngBox = self.__wTree.get_widget("hboxOptipng")
self.__comboboxFileType = self.__wTree.get_widget("comboboxFileType")
self.__hscaleCompression = self.__wTree.get_widget("hscaleCompression")
self.__labelScaleMax = self.__wTree.get_widget("labelScaleMax")
self.__window.connect("destroy", self._destroy)
dic = {
"on_buttonOK_clicked": self.__buttonOKClicked,
"on_buttonReset_clicked": self.__buttonResetClicked,
"on_hscaleCompression_value_changed": self.__scaleCompressionValueChanged,
"on_comboboxFileType_changed": self.__comboboxFileTypeChanged,
"on_buttonInstallOptipng_clicked": self.__buttonInstallOptipng,
"on_buttonGetCurrentHeight_clicked": self.__buttonGetCurrentHeightClicked,
"on_spinbuttonNumberOfConnections_value_changed":self.__spinbuttonNumberOfConnections_value_changed,
"on_comboboxClipboard_changed":self.__comboboxClipboard_changed,
"on_checkbuttonOneInstance_toggled":self.__checkbuttonOneInstance_toggled,
"on_spinbuttonHeight_value_changed":self.__spinbuttonHeight_value_changed,
"on_spinbuttonThumb_value_changed":self.__spinbuttonThumb_value_changed,
"on_checkbuttonNotification_toggled":self.__checkbuttonNotification_toggled,
"on_checkbuttonIcon_toggled":self.__checkbuttonIcon_toggled,
"on_checkbuttonBlink_toggled":self.__checkbuttonBlink_toggled,
"on_checkbuttonUseProxy_toggled":self.__on_checkbuttonUseProxy_toggled,
"on_entryProxyAddress_changed":self.__on_entryProxyAddress_changed,
"on_entryProxyPort_changed":self.__on_entryProxyPort_changed,
# "on_entryProxyUserName_changed":self.__on_entryProxyUserName_changed,
# "on_entryProxyPassword_changed":self.__on_entryProxyPassword_changed,
"on_comboboxProxyAuthentication_changed":self.__on_comboboxProxyAuthentication_changed
}
self.__wTree.signal_autoconnect(dic)
self.__checkInstalledComponents()
self.__initUploaderTabs()
self.__loadSettings()
self.__window.show()
#hide not yet implemented elements
self.__wTree.get_widget("buttonInstallOptipng").hide()
def testAddNotepad(self):
settings = Settings()
settings.load('testSettings.ini')
notepads = settings.getNotepads()
self.assertEqual(2, len(notepads))
settings.addNotepad({'type' : 'local', 'name' : 'Sample2', 'path' : 'C:/temp'})
notepads = settings.getNotepads()
self.assertEqual(3, len(notepads))
self.assertEqual('Sample2', notepads[2]['name'])
def __init__(self, parent = None) :
QDialog.__init__(self, parent)
layout = QVBoxLayout()
self.settings = Settings()
self.edits = dict()
for key in Settings.values.keys():
layout.addLayout(self.createSettingField(key))
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
self.setLayout(layout)
def initVlaues(self):
self.stprWorkHours.setIntValue_(fh.secToHours(Settings.get("workDayLength")))
self.edtWorkHours.setIntValue_(self.stprWorkHours.intValue())
self.stprNotificationTime.setIntValue_(Settings.get("notificationTime"))
self.edtNotificationTime.setIntValue_(self.stprNotificationTime.intValue())
self.stprNotificationRepeatTime.setIntValue_(Settings.get("notificationRepeatTime"))
self.edtNotificationRepeatTime.setIntValue_(self.stprNotificationRepeatTime.intValue())
workEndTime = datetime.datetime.strptime(Settings.get("workEndTime"), "%H:%M").time()
someDate = datetime.datetime.combine(datetime.datetime.now(), workEndTime)
self.dpkrWorkStarts.setDateValue_(fh.datetimeToNSDate(someDate))
self.edtLogEditCommand.setStringValue_(Settings.get("logEditCommand"))
self.chbShowWorkTill.setState_(1 if Settings.get("showWorkTill") else 0)
self.chbShowDateTime.setState_(1 if Settings.get("showDateTime") else 0)
self.chbShowNotification.setState_(1 if Settings.get("showNotification") else 0)
self.chbSoundOnNotification.setState_(1 if Settings.get("soundOnNotification") else 0)
self.edtDateTimeFormat.setStringValue_(Settings.get("logDateTimeFormat"))
self.edtDateTimeFormat.setEnabled_(self.chbShowDateTime.state())
self.showNotification_(self)
def __init__(self, aArgv):
self.mSettings = Settings(aArgv[3] + aArgv[4] + ":" + aArgv[5], aArgv[6] + aArgv[7] + ":" + aArgv[8])
# Configuring the logger.
self.mLogger = logging.getLogger(aArgv[1])
self.mLogger.propagate = False
handler = logging.FileHandler("/tmp/" + aArgv[1] + ".log")
formatter = logging.Formatter("[%(asctime)s][%(threadName)28s][%(levelname)8s] - %(message)s")
handler.setFormatter(formatter)
self.mLogger.addHandler(handler)
self.mLogger.setLevel(self.mSettings.get("logging", "level"))
self.mCrittnick = aArgv[1]
# TODO: Implement sequential starting (in order of dependencies).
# This is a matter of performing full startup procedure properly.
self.mRites = {}
self.mLogger.debug("Initializing the post office.")
self.mPostOffice = PostOffice(self)
self.mGracefulShutdown = False
# FIXME: Rites should be started in appropriate sequence, according to dependencies.
# TODO: Remove the hardcoded number of services.
rites = [Rites.RiteCommon.REGISTRY, Rites.RiteCommon.HEARTBEAT] + [aArgv[9]]
for rite in rites:
self.mLogger.info("Spawning the %s rite." % rite)
if rite in self.mRites:
# TODO: For now this is ok. If e.g. rites are started recursively, then this will not work!
self.mLogger.critical("Rite %s has been already started." % rite)
sys.exit(1)
else:
self.mRites[rite] = createRite(self, rite)
for rite in rites:
self.mLogger.info("Starting the %s rite." % rite)
self.mRites[rite].start()
# Spawning the behavior.
self.mLogger.debug("Spawning the behavior.")
self.mBehavior = CritterBehavior(self)
self.mBehavior.setDaemon(True)
self.mBehavior.start()
self.mLogger.debug("Starting the post office.")
self.mPostOffice.start()
class MainWindow(QMainWindow):
l = logging.getLogger('MainWindow')
def __init__(self, app):
QMainWindow.__init__(self, None)
self.l.debug('Initializing MainWindow ...')
self.setWindowTitle('MynPad')
app.setWindowIcon(QIcon(':/icons/mynpad.png'))
if os.name == 'nt':
# On Windows, make sure to use a unique Application User Model Id, otherwise
# Windows shows the default python icon in the taskbar
# see http://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7
myappid = 'afester.mynpad'
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
myappid)
self.theApplication = app
app.aboutToQuit.connect(self.saveState)
# read the local configuration file
iniPath = 'mynpad.ini'
if not os.path.exists(iniPath):
iniPath = os.path.join(expanduser("~"), iniPath)
self.settings = Settings(iniPath)
self.settings.load()
# Set up the menu bar
menuBar = QMenuBar(self)
exitAction = QAction("Exit", self, triggered=self.theApplication.exit)
fileMenu = menuBar.addMenu("&File")
fileMenu.addAction(exitAction)
aboutAction = QAction("About ...", self, triggered=self.handleAbout)
helpMenu = menuBar.addMenu("&Help")
helpMenu.addAction(aboutAction)
self.setMenuBar(menuBar)
# Setup the status bar
self.statusBar = QStatusBar()
self.statusBar.showMessage("Ready.")
self.setStatusBar(self.statusBar)
self.mainWidget = CentralWidget(self, self.settings)
self.mainWidget.updateWindowTitle.connect(self.updateWindowTitle)
self.setCentralWidget(self.mainWidget)
# Reset main window size and position
pos = self.settings.getMainWindowPos()
self.move(pos.x(), pos.y())
size = self.settings.getMainWindowSize()
self.resize(size)
# initialize the browser tree (add the top nodes and expand the saved path)
self.mainWidget.browserWidget.initialize()
def updateWindowTitle(self, title):
self.setWindowTitle('{} - MynPad'.format(title))
def saveState(self):
# Make sure that the current notepad page is saved
self.mainWidget.editorWidget.save()
# Note: there is no way to have eclipse shutdown the application faithfully,
# see also http://stackoverflow.com/questions/677531/is-it-possible-for-eclipse-to-terminate-gently-instead-of-using-sigkill
path = self.mainWidget.browserWidget.getCurrentPath()
self.settings.setBrowserPath(path)
self.settings.setMainWindowPos(self.pos())
self.settings.setMainWindowSize(self.size())
self.settings.save()
# Close all notepads - TODO (HACK)
for x in range(
0,
self.mainWidget.browserWidget.browserView.topLevelItemCount()):
notepad = self.mainWidget.browserWidget.browserView.topLevelItem(
x).getNotepad()
notepad.close()
def handleAbout(self):
appVersion = "Development version"
pythonVersion = "%s.%s.%s (%s)" % (
sys.version_info[0], sys.version_info[1], sys.version_info[2],
sys.version_info[3])
pyQtVersion = PYQT_VERSION_STR
pyQtQtVersion = QT_VERSION_STR
qtRuntimeVersion = qVersion()
platformSystem = platform.system()
platformRelease = platform.release()
QMessageBox.about(
self, "About MynPad",
"Copyright \u00a9 2015 by Andreas Fester<br/>" + "<table>" +
"<tr><th align=\"right\">Application version:</th><td>{}</td></tr>"
.format(appVersion) +
"<tr><th align=\"right\">Python version:</th><td>{}</td></tr>".
format(pythonVersion) +
"<tr><th align=\"right\">PyQt version:</th><td>{} for Qt {}</td></tr>"
.format(pyQtVersion, pyQtQtVersion) +
"<tr><th align=\"right\">Qt runtime version:</th><td>{}</td></tr>".
format(qtRuntimeVersion) +
"<tr><th align=\"right\">Operating System:</th><td>{} {}</td></tr>"
.format(platformSystem, platformRelease) +
"<tr><th align=\"right\">sqlite version:</th><td>{}</td></tr>".
format(sqlite3.version) +
"<tr><th align=\"right\">sqlite runtime version:</th><td>{}</td></tr>"
.format(sqlite3.sqlite_version) + "</table>")
class Main():
def __init__(self, selected_vol, selected_music):
self.selected_vol = selected_vol
self.selected_music = selected_music
def game_intro(self):
self.about = About.About()
self.func = Functions.Functions()
self.high = Highscore()
self.intro = True
self.sett = Settings(self.selected_vol, self.selected_music)
bg_y = 0
while (self.intro):
py.display.set_caption("Main")
rel_y = bg_y % bg.get_rect().height
display_screen.blit(bg, (0, rel_y - bg.get_rect().height))
if rel_y < display_height:
display_screen.blit(bg, (0, rel_y))
bg_y += 0.1
# BUTTONS
mg_menu_button = self.func.button(
"Mini Games", WHITE, display_width / 2 - main_menu_buttonx / 2,
225, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR)
highscores_button = self.func.button(
"Highscores", WHITE, display_width / 2 - main_menu_buttonx / 2,
300, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR)
settings_button = self.func.button(
"Settings", WHITE, display_width / 2 - main_menu_buttonx / 2,
375, main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR)
instr_menu_button = self.func.button(
"About", WHITE, display_width / 2 - main_menu_buttonx / 2, 450,
main_menu_buttonx, main_menu_buttony, IACOLOR, ACOLOR)
exit_button = self.func.button("Exit", WHITE, 20,
display_height - instr_buttony - 20,
instr_buttonx, instr_buttony,
IACOLOR, ACOLOR)
# TEXT
text_surface, text_rect = self.func.text_objects(
"MAIN MENU", large_text, WHITE)
text_rect.center = (display_width / 2, 150)
display_screen.blit(text_surface, text_rect)
for event in py.event.get():
if event.type == py.QUIT:
py.quit()
quit()
if event.type == py.MOUSEBUTTONDOWN:
mouse_pos = py.mouse.get_pos()
if mg_menu_button.collidepoint(mouse_pos):
self.value = 'mini'
self.intro = False
if highscores_button.collidepoint(mouse_pos):
self.high.loop()
if instr_menu_button.collidepoint(mouse_pos):
self.about.loop()
if settings_button.collidepoint(mouse_pos):
self.selected_vol, self.selected_music = self.sett.loop(
)
if exit_button.collidepoint(mouse_pos):
py.quit()
quit()
py.display.update()
return self.selected_vol, self.selected_music, self.value
import requests
from Settings import Settings
from ApiResponse import ApiResponse
from Profile import Profile
from ObjectBuilder import ObjectBuilder
# Initialize the setings
settings = Settings()
# Build the request to get the token
request = requests.post(settings.settings_data["Urls"]["AuthLoginUrl"],
json=settings.get_api_auth_data())
# Token request response
response = request.json()
# Object to represent the API response
api_response = ApiResponse()
api_response.process_object(response)
if api_response.success:
# Build bearer token value
headers = {"Authorization": "Bearer " + api_response.data["Token"]}
# Used to mock some data
builder = ObjectBuilder()
# Get single poly ID
poly_id_request = requests.put(
settings.settings_data["Urls"]["GetPolyIdUrl"],
json=builder.profile_0.get_json_object(),
"""
Copyright 2019 Akvelon Inc.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
"""
from RPCHost import RPCHost
from SQSQueue import SQSQueue
from tx import Transaction
from Settings import Settings
import time, boto3
app_settings = Settings()
sqs = boto3.client('sqs')
bitcoind_url = 'http://' + app_settings['rpc-user'] + ':' + app_settings[
'rpc-password'] + '@' + app_settings['rpc-url']
host = RPCHost(bitcoind_url)
incoming_tx_queue = SQSQueue(url=app_settings['prepared-transaction-sqs-url'])
def loop():
try:
print('Round start')
incoming_tx = incoming_tx_queue.get_message()
if incoming_tx:
print('Got tx, working on it')
def WhichTable(NameTable: str):
if NameTable == Settings.Var_PR(): return SQLPR
elif NameTable == Settings.Var_MR(): return SQLMR
def setUpClass(self):
Settings.loadSettings(self.SETTINGS_PATH)
self.settings = Settings("test")
class SettingsTest(unittest.TestCase):
SETTINGS_PATH = os.path.expanduser('settingstest.xml')
@classmethod
def setUpClass(self):
Settings.loadSettings(self.SETTINGS_PATH)
self.settings = Settings("test")
def test_string(self):
defaulttest = self.settings.get('defaulttest', 'defaulttest')
self.settings.set('gettest', 'gettest')
gettest2 = self.settings.get('gettest', 'defaulttest')
self.assertEquals(defaulttest, 'defaulttest')
self.assertEquals(gettest2, 'gettest')
def test_int(self):
gettest1 = self.settings.get('gettest', 4)
self.settings.set('gettest', 1)
gettest2 = self.settings.get('gettest', 4)
self.assertEquals(gettest1, 4)
self.assertEquals(gettest2, 1)
def test_bool(self):
gettest1 = self.settings.get('gettest', False)
self.settings.set('gettest2', True)
self.settings.set('gettest3', False)
gettest2 = self.settings.get('gettest2', False)
gettest3 = self.settings.get('gettest3', False)
self.assertEquals(gettest1, False)
self.assertEquals(gettest2, True)
self.assertEquals(gettest3, False)
def test_write(self):
self.settings.write()
self.assertTrue(os.path.exists(self.SETTINGS_PATH))
@classmethod
def tearDownClass(self):
os.remove(self.SETTINGS_PATH)
def __init__(self, argv):
self.loaded = False
self.config = wx.Config("OSW-IDE", style=wx.CONFIG_USE_LOCAL_FILE)
self.path = os.getcwd()
# All functions here will be called upon exit
self.onExit = [Settings.saveConfig]
Settings()
# All defined platforms
self.platforms = self.getPlatformsFromMakefile()
self.platformOnly = None
self.excludedPlatforms = list()
self.activePlatform = self.platforms.index("telosb")
# Flag indicates that next thread's output shouldn't trigger
# force switching to info area tab.
self.supressTabSwitching = False
self.targets = [None]
self.targetType = "USB"
self.activeThreads = {}
self.onExit.append(self.killAllThreads)
if LOG_TO_FILE:
path = os.getcwd()
os.chdir(self.path)
self.logFile = open(LOG_FILE_NAME, "a")
os.chdir(path)
self.onExit.append(self.logFile.close)
# this is path from /osw/tools/IDE
self.pathToMansos = os.path.join(self.path, "../..")
# Try to get system default font
#font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
#self.fontName = font.GetFaceName()
#if self.fontName != "":
# print "Using system default font: {}".format(self.fontName)
#else:
self.fontName = "Courier New"
# print "Can't find system default font, defaulting to {}".\
# format(self.fontName)
self.listenModules = list()
self.editors = list()
icon = os.path.normpath('../../doc/osw-32x32.ico')
### Module initializations
# Visual objects here can be used in forms only after they have been re-parented
# using their Reparent() function, else they won't be visible!
self.emptyFrame = wx.Frame(None)
# Defines seal syntax
self.sealSyntax = SealSyntax(self)
# Init translation module
Translater(self)
# Init output_tools
#self.outputTools = OutputTools(self.emptyFrame, self)
# Init outputArea for info, 1st tab
self.infoArea = OutputArea(self.emptyFrame, self, 0)
self.printInfo = self.infoArea.printLine
self.clearInfoArea = self.infoArea.clear
# Init blockly handler
if os.path.exists(
os.path.join(self.path, Settings.get("blockly_location"))):
self.blockly = Blockly(self.emptyFrame, self)
self.foundBlockly = True
else:
print "Warning: No SEAL-Blockly found!"
self.foundBlockly = False
# Init seal parser
self.sealParser = seal_parser.SealParser("msp430", self.printInfo,
False, True)
# Init tab manager
self.tabManager = TabManager(self.emptyFrame, self)
# Init listenModule
self.listenModules.append(ListenModule(self.emptyFrame, self))
self.editPanel = ScrolledPanel(self.emptyFrame)
self.editWindow = EditStatement(self.editPanel, self)
self.frame = Frame(None, "OSW IDE", (0, 0), (0, 0), self)
#self.outputTools.addTools()
self.compiler = DoCompile(self)
self.uploader = DoUpload(self)
### Shortcuts
# This allows modules to be disabled and dummy functions attached, so other
# modules can keep saving the day... Each module updates his functions at
# startup and restores them at termination. All function calls between modules
# should go through here, but this ain't perfect world :(
self.getKeywords = self.sealSyntax.getKeywords
#self.printInfo = self.dummyPrint
self.printOutput = self.dummyPrint
# Check if icon can be found
if os.path.exists(icon):
self.frame.SetIcon(wx.Icon(icon, wx.BITMAP_TYPE_ICO, 32, 32))
else:
self.logMsg(LOG_WARNING, "Icon not found in '{}'!".format(icon))
# Check that everything is OK
assert len(self.emptyFrame.GetChildren()) == 0, \
"There are parentless objects after API initialization.\n{}".format(\
self.emptyFrame.GetChildren())
self.syncModuleCheckboxes()
# Initialize upload targets
self.uploadTargets = ([], localize('the default device'))
# Load last used tabs
self.tabManager.loadRememberedTabs()
for x in argv:
self.tabManager.addPage(x)
self.frame.auiManager.Update()
self.loaded = True
self.frame.checkToggleState()
Motelist.startPeriodicUpdate()
self.onExit.append(Motelist.stopPeriodicUpdate)
self.loadUserMotes()
def setupSettings(self):
builtins.settings = Settings(f'{userfiles}/config.ott')
if 'panda-path' not in settings:
settings['panda-path'] = 'None'
def __init__(self,
settings_bin_path='',
channel_num=0,
device='dut',
show_progressbar=False):
print 'Creating PedestalCalculations instance'
self.show_pb = show_progressbar
self.settings = Settings()
self.ch = channel_num
self.device = device
self.LoadSettingsBinary(settings_bin_path)
self.out_dir = self.settings.output_dir
self.sub_dir = self.settings.sub_dir
self.file_name = self.settings.file_name
self.tree_name = self.settings.tree_name
self.slide_leng = self.settings.sliding_length
self.run = self.settings.run
self.ana_events = self.settings.ana_events
self.ped_branches = [
'diaPed', 'diaPedSigma', 'cm', 'diaPedCmc', 'diaPedSigmaCmc',
'diaSignal', 'diaSignalCmc'
]
self.raw_tel_branches_dic = {
0: 'D0X_ADC',
1: 'D0Y_ADC',
2: 'D1X_ADC',
3: 'D1Y_ADC',
4: 'D2X_ADC',
5: 'D2Y_ADC',
6: 'D3X_ADC',
7: 'D3Y_ADC'
}
self.raw_dut_branch = 'DiaADC'
self.rootFile = None
self.rootTree = None
self.utils = Utils()
self.read_branch = self.raw_tel_branches_dic[
0] if self.device == 'telx0' else self.raw_tel_branches_dic[
1] if self.device == 'tely0' else self.raw_tel_branches_dic[
2] if self.device == 'telx1' else self.raw_tel_branches_dic[
3] if self.device == 'tely1' else self.raw_tel_branches_dic[
4] if self.device == 'telx2' else self.raw_tel_branches_dic[
5] if self.device == 'tely2' else self.raw_tel_branches_dic[
6] if self.device == 'telx3' else self.raw_tel_branches_dic[
7] if self.device == 'tely3' else self.raw_dut_branch
self.hit_factor = self.settings.clust_hit[
0] if self.device == 'telx0' else self.settings.clust_hit[
1] if self.device == 'tely0' else self.settings.clust_hit[
2] if self.device == 'telx1' else self.settings.clust_hit[
3] if self.device == 'tely1' else self.settings.clust_hit[
4] if self.device == 'telx2' else self.settings.clust_hit[
5] if self.device == 'tely2' else self.settings.clust_hit[
6] if self.device == 'telx3' else self.settings.clust_hit[
7] if self.device == 'tely3' else self.settings.clust_hit[
8]
self.seed_factor = self.settings.clust_seed[
0] if self.device == 'telx0' else self.settings.clust_seed[
1] if self.device == 'tely0' else self.settings.clust_seed[
2] if self.device == 'telx1' else self.settings.clust_seed[
3] if self.device == 'tely1' else self.settings.clust_seed[
4] if self.device == 'telx2' else self.settings.clust_seed[
5] if self.device == 'tely2' else self.settings.clust_seed[
6] if self.device == 'telx3' else self.settings.clust_seed[
7] if self.device == 'tely3' else self.settings.clust_seed[
8]
self.read_branch += '[{c}]'.format(c=self.ch)
self.np_type = self.settings.dut_np_data_type if self.device == 'dut' else self.settings.tel_np_data_type
# self.hit_factor = self.settings.dut_hit_factor if self.device == 'dut' else self.settings.tel_hit_factor
self.device_ADC = np.zeros(self.slide_leng, dtype=self.np_type)
self.device_ped = np.zeros(self.slide_leng, dtype='float32')
self.device_sigma = np.zeros(self.slide_leng, dtype='float32')
self.device_signal = np.zeros(self.slide_leng, dtype='float32')
self.device_ADC_mean = np.zeros(self.ana_events, dtype='float32')
self.device_ADC_sigma = np.zeros(self.ana_events, dtype='float32')
self.device_ADC_is_ped = np.zeros(self.ana_events, dtype='?')
self.device_ADC_is_hit = np.zeros(self.ana_events, dtype='?')
self.device_ADC_is_seed = np.zeros(self.ana_events, dtype='?')
self.adc = 0
self.mean = 0.0
self.sigma = 0.0
self.mean_sq = 0.0
self.elem = 0
self.device_ADC_all = np.zeros(self.ana_events, dtype=self.np_type)
self.CalculatePedestals()
def main():
settings = Settings()
analytics = Analytics()
novelty = Novelty()
cmd_line_args_success = settings.update_command_line_args()
if not cmd_line_args_success:
return
print("Settings:" +
"\n".join([f"{i} : {j}" for i, j in vars(settings).items()]))
hws = [
Hardware(None, i, settings.min_program_length,
settings.max_program_length) for i in range(settings.pop_size)
]
game = FlappyDarwin(
hws, settings.ticks_per_update,
settings.num_tests if settings.selection == "lexicase" else 1,
(lambda: 0) if settings.fitness == "novelty" else (lambda: time()))
inst_lib = generate_inst_lib(game)
for hw in hws:
hw.inst_lib = inst_lib
[hw.generate_program() for hw in hws]
best_fitness = [0]
fitness_data = []
gen = 1
if settings.save_file:
print(F"LOADING FROM EXISTING SAVED GP FILE: {settings.save_file}")
hws, gen, gen_finished_test = load_programs(inst_lib, settings)
game.generation = gen
game.gen_finished_test = gen_finished_test
if settings.fitness == "novelty":
load_novelty_archive(novelty)
while not game.QUIT_SIGNAL:
print(F"Generation: {gen}")
game.set_hardware(hws)
game.start()
for i, hw in enumerate(hws):
hw.cache_fitness(game.birds[i].fitness)
local_best = max(hws, key=lambda hw: min(hw.fitness))
fitness_data.append(sum(local_best.fitness) / len(local_best.fitness))
if min(local_best.fitness) > min(best_fitness):
best_fitness = local_best.fitness
print(local_best)
print("Finished with fitness", local_best.fitness)
print("____________________________")
if settings.fitness == "novelty":
assert settings.selection != "lexicase", "Lexicase is not compatible with Novelty."
dists = novelty.select([(bird.rect.x + bird.last_frame_alive,
clamp(bird.rect.y, 0, game.HEIGHT))
for bird in game.birds])
for i, hw in enumerate(hws):
hw.cache_fitness(dists[i])
copy_best = local_best.copy()
copy_best.traits = 0
if settings.selection == "tournament":
hws = tournament(hws)
elif settings.selection == "elite":
hws = elite(hws, len(hws) // 2)
elif settings.selection == "lexicase":
hws = lexicase(hws)
elif settings.selection == "roulette":
hws = roulette(hws)
else:
raise NotImplementedError(
F"Invalid Selection Scheme: {settings.selection}")
[mutate(hw) for hw in hws]
recombination(hws)
for i, hw in enumerate(hws):
hw.traits = i
# Keep around the best performing from the previous generation & reset its hardware
hws[0] = copy_best
hws[0].traits = 0
gen += 1
if gen in {10, 50, 100, 250, 500, 1500, 2500} or not gen % 1000:
save_programs(gen, hws, game.gen_finished_test)
analytics.save(gen, fitness_data)
fitness_data.clear()
if settings.fitness == "novelty":
save_novelty_archive(novelty)
def processCommand(self, nick, msg, channelUsers):
self.init = Settings().keywords
self.gameTitle = self.init["Titles"]["game-hotpotato"]
output = []
msg = msg.strip()
cmd = msg.split(" ")[0]
args = []
if len(msg.split(" ")) > 1:
args = msg.split(" ")
args.remove(args[0])
if self.init["GameCommands"]["addPlayer"].lower() == cmd.lower():
if args:
for arg in args:
if "alreadyin" == self.addPlayer(HotPotatoPlayer(arg, ),
channelUsers):
output.append(
(self.init["Inform"]
["hijack-playeralreadyin"].replace(
self.init["Substitutions"]["sendnick"],
name), 1))
elif "nonexistent" == self.addPlayer(
HijackPlayer(name, health), channelUsers):
nopeMsg = self.init["Inform"][
"hotpotato-nonexistentplayer"]
nopeMsg = nopeMsg.replace(
self.init["Substitutions"]["sendnick"], name)
output.append((nopeMsg, 1))
else:
output.append(
("{nick} joined the game.".format(nick=name, ), 1))
elif self.init["GameCommands"]["leave"].lower() == cmd.lower():
who = []
hasLeft = False
if args:
who = args
else:
who = [nick]
for w in who:
if self.removePlayer(w):
leftMsg = random.choice(
self.init["Choices"]["hijack-leavegame"].split(
self.init["Splitters"]["choices-hijack"]))
leftMsg = leftMsg.replace(
self.init["Substitutions"]["sendnick"], w)
output.append((leftMsg, 1))
hasLeft = True
if hasLeft:
output.append(("Number of people playing {g}: {num}".format(
g=self.gameTitle, num=str(len(self.players))), 0))
elif self.init["Commands"]["startplaying"].lower() == cmd.lower():
if self.started:
pass
elif self.players:
self.started = True
self.currentHolder = random.choice(list(self.players.values()))
output.append(
(self.init["Inform"]["hotpotato-startplaying"], 1))
output.append(
(self.init["Choices"]["hotpotato-startpass"].replace(
self.init["Substitutions"]["sendNick"],
self.currentHolder.name), 0))
else:
## No one's playing.
pass
elif self.init["GameCommands"]["hotpotato-pass"].lower() == cmd.lower(
):
if 1 <= len(args):
if args[0].lower() in self.players:
self.currentHolder = self.players[args[0].lower()]
def __init__(self):
Game.__init__(self, Settings().keywords["Titles"]["game-hijack"])
bottom_right = (min_loc[0] + w, min_loc[1] + h)
cv2.rectangle(frame, min_loc, bottom_right, (0, 0, 255), 3)
cv2.imshow('this', matches[0])
ph = min_loc[1]
pw = math.ceil((min_loc[0] + h) / 2)
return True, min_loc, bottom_right, ph, pw
return False, None, None, None, None
if __name__ == '__main__':
nwt_s = Settings('./nwt_settings.txt', True)
nwt = nwtConnection(nwt_s.dict['roboRioAddress'],
nwt_s.dict['sdTableName'], nwt_s.dict['cpTableName'])
gt = GearTracker('./templates/')
nwt.find_stream()
cap = cv2.VideoCapture(nwt.streamURL)
while True:
ret, frame = cap.read()
if ret:
tracking, topLeft, bottomRight, ph, pw = gt.track(frame)
def login(self):
self.userInfo[
'loginUser.loginName'] = self.login_widget.usernameLineEdit.text()
self.userInfo[
'loginUser.loginPassword'] = self.login_widget.passwordLineEdit.text(
)
self.login_widget.setDisabled(True)
worker = LoginWorker(self)
worker.start()
@Slot(str)
def handleLoginStatus(self, status):
print(status)
@Slot(bool)
def handleLoginResponse(self, response):
print(response)
if response == 'successful':
self.loginStatus = True
self.close()
else:
QMessageBox.critical(self, 'Error', response)
self.login_widget.setDisabled(False)
if __name__ == '__main__':
app = QApplication(sys.argv)
settings = Settings('./temp/settings.json')
login = UserLoginDialog(settings)
login.exec_()
from Settings import Settings
'''
Start the game by running this script
'''
if __name__ == '__main__':
Settings() # Calls the Settings Class
def FindAllItemMP(Table: str, ItemToFind: str):
if Table == Settings.Var_Process1():
Type = Settings.Dir_BD()
else:
Type = Settings.Dir_PBD()
Refs, Workers, Providers, References, Presentations, NumRems, NumPres, TotalWeight, InitialDate, FinalDate, CodeBr, NumCoils = \
SQLMP.FindALLMP(Type)
if ItemToFind == Settings.Var_Comp26(): return Refs
elif ItemToFind == Settings.Var_Comp15(): return Workers
elif ItemToFind == Settings.Var_Comp14(): return Providers
elif ItemToFind == Settings.Var_Comp13(): return References
elif ItemToFind == Settings.Var_Comp12(): return Presentations
elif ItemToFind == Settings.Var_Comp9(): return NumRems
elif ItemToFind == Settings.Var_Comp3(): return NumPres
elif ItemToFind == Settings.Var_Comp6(): return NumCoils
elif ItemToFind == Settings.Var_Comp4(): return TotalWeight
elif ItemToFind == Settings.Var_Comp19(): return InitialDate
elif ItemToFind == Settings.Var_Comp20(): return FinalDate
elif ItemToFind == Settings.Var_Comp1(): return CodeBr
def load_from_cpu(settings, model_emb, model_class):
state_dict_emb = torch.load(settings.checkpointroot_load_emb,
map_location=torch.device('cpu'))["state_dict"]
state_dict_class = torch.load(
settings.checkpointroot_load_class,
map_location=torch.device('cpu'))["state_dict"]
params_emb = get_state_dict(state_dict_emb)
params_class = get_state_dict(state_dict_class)
model_emb.load_state_dict(params_emb)
model_class.load_state_dict(params_class)
return model_emb, model_class
if __name__ == '__main__':
settings = Settings().parse_arguments()
settings.dataroot = "small_test_mnist.npz"
settings.stage = "Test"
dataloader = Dataset(settings).create_dataset(do_transform=False,
type_dataloader="Single")
model_emb, model_class = load_models(settings)
batchsize = settings.batch_size
n_batches = len(dataloader.dataset.data[0]) // batchsize
accuracy = 0.0
with torch.no_grad():
for i, data in enumerate(
tqdm(dataloader, total=n_batches, desc="Batch: ",
leave=False)):
embedding = model_emb.predict(data["images"])
model_class.predict(embedding)
model_class.set_ground_truth(data["labels"])
def Check_And_Add_ListMP():
Ref, Worker, Provider, Reference, Presentation, NumRem, NumPre, WeightT, InitialD, FinalD, CodeB, Num_Coils = SQLMP.FindALLMP(
Settings.Dir_BD())
Ref2, Worker2, Provider2, Reference2, Presentation2, NumRem2, NumPre2, WeightT2, InitialD2, FinalD2, CodeB2, Num_Coils2 = SQLMP.FindALLMP(
Settings.Dir_CBD())
New_ID = []
New_Refs = []
New_Workers = []
New_Providers = []
New_References = []
New_Presentation = []
New_NumRem = []
New_NumPre = []
New_TotalW = []
New_Initial = []
New_Final = []
New_CodeB = []
New_NumCoils = []
for x in range(len(Ref)):
if Ref[x] not in New_Refs:
New_Refs.append(Ref[x])
New_Workers.append(Worker[x])
New_Providers.append(Provider[x])
New_References.append(Reference[x])
New_Presentation.append(Presentation[x])
New_NumRem.append(NumRem[x])
New_NumPre.append(NumPre[x])
New_TotalW.append(WeightT[x])
New_Initial.append(InitialD[x])
New_Final.append(FinalD[x])
New_CodeB.append(CodeB[x])
New_NumCoils.append(Num_Coils[x])
for x in range(len(Ref2)):
if Ref2[x] not in New_Refs:
New_Refs.append(Ref2[x])
New_Workers.append(Worker2[x])
New_Providers.append(Provider2[x])
New_References.append(Reference2[x])
New_Presentation.append(Presentation2[x])
New_NumRem.append(NumRem2[x])
New_NumPre.append(NumPre2[x])
New_TotalW.append(WeightT2[x])
New_Initial.append(InitialD2[x])
New_Final.append(FinalD2[x])
New_CodeB.append(CodeB2[x])
New_NumCoils.append(Num_Coils2[x])
for x in range(len(Num_Coils)):
New_ID.append(x + 1)
SQLMP.DeleteALLMP(Settings.Dir_CBD())
SQLMP.DeleteALLMP(Settings.Dir_BD())
for x in range(len(New_Refs)):
SQLMP.AddMP(Settings.Dir_CBD(), New_ID[x], New_Refs[x],
New_Workers[x], New_Providers[x], New_References[x],
New_Presentation[x], New_NumRem[x], New_NumPre[x],
New_TotalW[x], New_Initial[x], New_Final[x],
New_CodeB[x], New_NumCoils[x])
SQLMP.AddMP(Settings.Dir_BD(), New_ID[x], New_Refs[x],
New_Workers[x], New_Providers[x], New_References[x],
New_Presentation[x], New_NumRem[x], New_NumPre[x],
New_TotalW[x], New_Initial[x], New_Final[x],
New_CodeB[x], New_NumCoils[x])
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self._ui = uic.loadUi("mainwindow.ui", self)
self.setAttribute(Qt.WA_QuitOnClose)
self.setAttribute(Qt.WA_DeleteOnClose)
# - private void MainForm_Load(object sender, EventArgs e)
self.recipe = Recipe() # - recipies
self.settings = Settings() # - settings
# self.settings.initialize()
# - ModbusClient PLC Connect
self.modbusClient = ModbusClient('192.168.0.10', 502)
self.modbusClient.parity = Parity.even
self.modbusClient.unitidentifier = 2
self.modbusClient.baudrate = 9600
self.modbusClient.stopbits = Stopbits.one
self.modbusClient.connect()
self.gas_out_valve = Valve(self.settings.gas_out_valve,
False,
modbus_client=self.modbusClient)
self.ar_valve = GasValve(self.settings.ar_valve, False, 0,
self.settings.ar_mfc, self.settings.ar_sccm)
self.o2_valve = GasValve(self.settings.o2_valve, False, 0,
self.settings.o2_mfc, self.settings.o2_sccm)
self.cf4_valve = GasValve(self.settings.cf4_valve, False, 0,
self.settings.cf4_mfc,
self.settings.cf4_sccm)
self.n2_valve = GasValve(self.settings.n2_valve, False, 0,
self.settings.n2_mfc, self.settings.n2_sccm)
self.vent_valve = Valve(self.settings.vent_valve,
False,
modbus_client=self.modbusClient)
self.pump_valve = Valve(self.settings.pump_valve,
False,
modbus_client=self.modbusClient)
# - public partial class MainForm : Form
self.discreteInputs = self.modbusClient.read_discreteinputs(0, 8)
self.holdingRegisters = convert_registers_to_float(
self.modbusClient.read_holdingregisters(0, 2))
print(self.holdingRegisters)
self.inputRegisters = self.modbusClient.read_inputregisters(0, 8)
print(self.inputRegisters)
self.coils = self.modbusClient.read_coils(0, 8)
print(self.coils)
self.modbusClient.write_single_coil(0, True)
self.modbusClient.write_single_register(0, 777)
self.modbusClient.write_multiple_coils(
0, [True, True, True, True, True, False, True, True])
self.modbusClient.write_multiple_registers(
0, convert_float_to_two_registers(3.141517))
self.modbusClient.close()
self.recipe_part = os.path.abspath('./recipies')
self.throttle_valve_angle = 0.0
self.timer_pump_for_vent = QTimer() # - pre_vent timer
self.valve_port = serial.Serial(
port=self.settings.comport_name,
baudrate=self.settings.comport_baudrate,
timeout=500,
write_timeout=500,
) # - com port variable
# todo comport checking initialization
# - private static Valve VentValve;
self.timer_send_receive_modbus = QTimer() # - plc call timer
self.timer_check_trhrottle = QTimer()
self.timer_pressure_read = QTimer() # - pressure call timer
self.timer_for_vent = QTimer() # - vent timer
self.timer_process = QTimer() # - process timer
self.timer_ignition = QTimer() # - ignition process timer
self.process_time_start = 0 # - starting process time
self.process_time_end = 0 # - ending process time
self.process_time = 0 # - process time
self.last_time = 0 # process remain time
# - private static string SerialMessage
self.pressure_read = 0.0 # - baratron pressure
self.pressure_angle = False # - pressure and status of the drosel valve's call
self.process_started = False # process status
self.pre_pump_process_started = False # pre pump process status
self.pressure_input = 0 # reading value from the recipe
self.throttle_valve = False # throttle valve variable
self.pump_for_vent = False # venting
self.vent_for_vent = False
self.lid_up_button = False
self.lid_down_button = False
self.vent_button = False
self.pump_button = False
self.ignition_start = False
self.start_button = False
self.stop_button = False
self.safe_button = False
self.chiller_ok = False
self.lid_down_bit = False # lid's bit status
self.process_end = False
self.venting = False
self.lid_closing = False
self.mfc_read = []
self.ar_mfc_read = []
self.o2_mfc_read = []
self.cf4_mfc_read = []
self.n2_mfc_read = []
self.sccm_ar = 0
self.sccm_o2 = 0
self.sccm_cf4 = 0
self.sccm_n2 = 0
self.mw_power = 0
self.generator_hb = []
self.read_recipes_from_folder()
self.timer_send_receive_modbus.start(300)
#Option 2 - generate images
# ═══════════════════════════════════════════
elif userinput == "2":
SaveImages()
userinput = menu()
# Option 3 - Send images
# ═══════════════════════════════════════════
elif userinput == "3":
SendImages()
userinput = menu()
# Option 4 - Settings
# ═══════════════════════════════════════════
elif userinput == "4":
Settings()
userinput = menu()
# Option 5 - Mark rendered image complete
# ═══════════════════════════════════════════
elif userinput == "5":
ViewRenderedImages()
userinput = menu()
# Option 6 - Mark rendered image complete
# ═══════════════════════════════════════════
elif userinput == "6":
ArchiveRenderedImage()
userinput = menu()
# All other options - Repeat menu
class App(QWidget):
cleanupEvent = pyqtSignal()
def __init__(self, resources):
super().__init__()
self.versionNumber = '1.2.7'
self.title = 'Monkey See Monkey Do v'+self.versionNumber
self.left = 10
self.top = 80
self.width = 640
self.height = 100
self.folderName = ''
self.imageList = []
self.numImages = 0
self.currentImageNumber = 0
self.currentTotalImageNumber = 0
self.hotSpotFilename = 'hotspots.json'
self.hotSpotFile = None
self.hotSpotSize = 50
self.currentHotSpot = None
self.startTime = None
self.endTime = None
self.robot = []
self.screen = QDesktopWidget().availableGeometry()
self.platform = platform.name()
self.resources = resources
print(self.screen)
print('Operating System: ', self.platform)
print('Screen: width:', self.screen.width(), 'height:', self.screen.height())
self.initUI()
def initUI(self):
self.readConfig()
self.portLabel = QLabel('Port(s): ', self)
self.portDisplay = QLineEdit(self)
self.portDisplay.setEnabled(False)
self.portRefreshButton = QPushButton(self)
self.portRefreshButton.setToolTip('Press to detect port of connected base station')
self.portRefreshButton.clicked.connect(self.refreshPorts)
self.portRefreshButton.setIcon(QIcon(self.resources['imgRefresh']))
self.portRefreshButton.setFixedWidth(24)
self.settingsButton = QPushButton()
self.settingsButton.setToolTip('Open the Settings Dialog')
self.settingsButton.setIcon(QIcon(self.resources['imgSettings']))
self.settingsButton.setMaximumWidth(24)
self.settingsButton.clicked.connect(self.openSettings)
self.connected = False
self.refreshPorts()
if self.showReferenceCreator:
self.referenceCreator = QPushButton('Create Reference', self)
self.referenceCreator.setToolTip('Create a reference file from the selected image set')
self.referenceCreator.clicked.connect(self.createReferenceFile)
self.referenceCreator.setEnabled(False)
self.folderButton = QPushButton('Select Folder', self)
self.folderButton.setToolTip('Select the folder that contains the content you would like to play')
self.folderButton.clicked.connect(self.folderButtonClicked)
self.folderLabel = QLabel('Selected Folder:', self)
self.selectedFolder = QLineEdit(self)
self.selectedFolder.setEnabled(False)
self.numLevelsLabel = QLabel('Number of Levels:', self)
self.numLevelsDisplay = QLineEdit(self)
self.numLevelsDisplay.setEnabled(False)
self.numImagesLabel = QLabel('Number of Images:', self)
self.numImagesDisplay = QLineEdit(self)
self.numImagesDisplay.setEnabled(False)
self.startLabel = QLabel('Press "Start" to begin game', self)
self.startButton = QPushButton('Start', self)
self.startButton.setToolTip('Start Game')
self.startButton.clicked.connect(self.startButtonClicked)
self.startButton.setEnabled(False)
self.hboxPort = QHBoxLayout()
self.hboxPort.addWidget(self.portLabel)
self.hboxPort.addWidget(self.portDisplay)
self.hboxPort.addWidget(self.portRefreshButton)
self.hboxPort.addWidget(self.settingsButton)
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.folderLabel)
self.hbox.addWidget(self.selectedFolder)
self.hboxNumLevels = QHBoxLayout()
self.hboxNumLevels.addWidget(self.numLevelsLabel)
self.hboxNumLevels.addWidget(self.numLevelsDisplay)
self.hboxNumImages = QHBoxLayout()
self.hboxNumImages.addWidget(self.numImagesLabel)
self.hboxNumImages.addWidget(self.numImagesDisplay)
self.vbox = QVBoxLayout()
self.vbox.addLayout(self.hboxPort)
self.vbox.addWidget(self.folderButton)
self.vbox.addLayout(self.hbox)
self.vbox.addLayout(self.hboxNumLevels)
self.vbox.addLayout(self.hboxNumImages)
if self.showReferenceCreator:
self.vbox.addWidget(self.referenceCreator)
self.vbox.addWidget(self.startLabel)
self.vbox.addWidget(self.startButton)
self.vbox.addStretch(4)
self.startPage = QWidget()
self.startPage.setLayout(self.vbox)
self.scene = QGraphicsScene()
self.graphicsView = GraphicsView(self.scene)
self.graphicsView.itemClickedEvent.connect(self.hotSpotClickedHandler)
self.graphicsView.keyPressed.connect(self.keyPressedHandler)
self.graphicsLayout = QVBoxLayout()
self.graphicsLayout.addWidget(self.graphicsView)
self.graphicsLayout.setContentsMargins(0, 0, 0, 0)
self.gamePage = QWidget()
self.gamePage.setLayout(self.graphicsLayout)
self.stackedLayout = QStackedLayout()
self.stackedLayout.addWidget(self.startPage)
self.stackedLayout.addWidget(self.gamePage)
self.stackedLayout.setCurrentIndex(0)
self.setLayout(self.stackedLayout)
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowIcon(QIcon(self.resources['icoMSMD']))
self.cleanupEvent.connect(self.cleanupStuff)
self.show()
self.bringToFront()
def readConfig(self):
self.config = configparser.ConfigParser()
fileCheck = self.config.read(self.resources['fileConfig'])
if(fileCheck == []):
QMessageBox.critical(self, 'Config Error!', 'config.ini was not found', QMessageBox.Ok)
self.robotSettings = self.config['robot']
self.appSettings = self.config['app']
# robot settings
self.upgradeTrigger = self.robotSettings['upgradeTrigger']
self.upgradeMode = self.robotSettings['upgradeMode']
self.minPowerToMove = self.robotSettings['minPowerToMove']
self.maxPowerToMove = self.robotSettings['maxPowerToMove']
# app settings
self.showReferenceCreator = int(self.appSettings.get('showReferenceCreator', '1'))
self.timeLimitMultiplier = float(self.appSettings.get('time_limit_multiplier', '1'))
self.levelToUnlock = int(self.appSettings.get('level_to_unlock', '0'))
def writeConfig(self):
self.robotSettings['upgradeTrigger'] = self.upgradeTrigger
self.robotSettings['upgradeMode'] = self.upgradeMode
self.robotSettings['minPowerToMove'] = self.minPowerToMove
self.robotSettings['maxPowerToMove'] = self.maxPowerToMove
self.appSettings['level_to_unlock'] = str(self.levelToUnlock)
with open(self.resources['fileConfig'], 'w') as configFile:
self.config.write(configFile)
def openSettings(self):
try:
SettingsIn = {
'upgradeTrigger': 'hotspot',
'upgradeMode': 'left',
'minPowerToMove': '80'}
self.settingsWindow = Settings(self.robotSettings)
self.settingsWindow.Closing.connect(self.settingsClosed)
self.settingsWindow.show()
self.setDisabled(True)
except:
print('ERROR - Setting.py Load Failed!')
def settingsClosed(self, message):
if(message == 'Abort'):
print('Settigns Aborted!')
elif(message == 'Closed'):
print('Settings Closed!')
# Set New Settings
newSettings = self.settingsWindow.getSettings()
self.upgradeTrigger = newSettings['upgradeTrigger']
self.upgradeMode = newSettings['upgradeMode']
self.minPowerToMove = newSettings['minPowerToMove']
self.maxPowerToMove = newSettings['maxPowerToMove']
self.writeConfig()
else:
print('ERROR - Unknown message returned from Settings.py Window!')
self.setDisabled(False)
def bringToFront(self):
self.setWindowState(self.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
self.activateWindow()
def refreshPorts(self):
if(self.connected):
for baseStation in self.robot:
baseStation.close()
comPorts = self.findPorts()
if(comPorts):
self.robot = []
self.portDisplayText = ''
for i, port in enumerate(comPorts):
self.robot.append(serial.Serial(port))
self.robot[i].baudrate = 115200
self.robot[i].timeout = 0.05
self.portDisplayText += (port + ' ')
self.portDisplay.setText(self.portDisplayText)
self.connected = True
else:
self.robot = []
self.connected = False
def folderButtonClicked(self):
# get folder with content in it from user
self.folderName = QFileDialog.getExistingDirectory(self, "Select Folder Location for Recorded Content")
print(self.folderName)
if os.path.isdir(self.folderName): # If it is a valid folder
self.numLevels = 0
self.numTotalImages = 0
self.listOfFilesInSelectedFolder = os.listdir(self.folderName)
self.folderList = []
self.folderListNameOnly = []
for name in self.listOfFilesInSelectedFolder:
fullFileName = os.path.join(self.folderName, name)
if os.path.isdir(fullFileName):
result = self.loadLevel(fullFileName) # load each level to make sure it is valid
if(result < 0): # if the folder is not a valid level, quit this function
return
self.folderList.append(fullFileName)
self.folderListNameOnly.append(name)
self.numLevels += 1
self.numTotalImages += result
self.folderListNameOnly = sorted(self.folderListNameOnly) # sort the resulting list of level folders (they should be named in order they will be played in)
if(self.numLevels > 0):
# multiLevel game selected
self.loadLevel(self.folderList[0]) # load the first level
self.numLevelsDisplay.setText(str(self.numLevels)) # display the number of levels in the selected folder
else:
# single level selected
result = self.loadLevel(self.folderName) # try to load the single level selected
if(result < 0): # if level is invalid, quit this function
return
self.numTotalImages = result
self.numLevelsDisplay.setText('1')
if(self.levelToUnlock>self.numLevels):
if(self.numLevels == 0):
self.levelToUnlock = 0
else:
self.levelToUnlock = self.numLevels-1
self.currentLevel = 0
self.numImagesDisplay.setText(str(self.numTotalImages))
self.startButton.setEnabled(True)
if self.showReferenceCreator:
self.referenceCreator.setEnabled(True)
self.selectedFolder.setText(self.folderName)
else:
QMessageBox.warning(self, 'Folder Error!', 'The folder does not exist!\nPlease select a valid folder', QMessageBox.Ok)
def loadLevel(self, levelToLoad):
try:
print('Trying to load '+levelToLoad)
self.hotSpotFile = open(levelToLoad+os.path.sep+self.hotSpotFilename, 'r')
self.hotSpotDict = json.load(self.hotSpotFile)
self.numHotSpotRecords = len(self.hotSpotDict)
# self.hotSpotCsv = csv.reader(self.hotSpotFile)
# next(self.hotSpotCsv)
# self.numHotSpotRecords = sum(1 for row in self.hotSpotCsv)
# self.hotSpotFile.seek(0)
# next(self.hotSpotCsv) #skip column labels on first line
self.hotSpotFile.close()
buildScanCodeTranslationTable(self.hotSpotDict)
except IOError:
QMessageBox.critical(self, 'Error: No hotspots.json', 'hotspots.json does not exist\nA Hot Spot file is required to play the game. Please select a complete and valid content folder', QMessageBox.Ok)
self.selectedFolder.setText('Error: No hotspots.json')
return -1
self.imageList = []
try:
for imageFile in sorted((imfile for imfile in os.listdir(levelToLoad) if imfile.endswith('.png'))):
self.imageList.append(QImage(levelToLoad+os.path.sep+imageFile))
except IOError:
QMessageBox.critical(self, 'Error: images reading', 'Images could not be read\nPlease select a complete and valid content folder', QMessageBox.Ok)
return -1
self.numImages = len(self.imageList)-1
if(self.numImages != self.numHotSpotRecords):
QMessageBox.critical(self, 'Error: Image Hotspot Mismatch', 'Error: number of images in level "'+str(levelToLoad)+'" do not match the number of hot spot records', QMessageBox.Ok)
return -1
return self.numImages
def startButtonClicked(self):
print('start')
self.stackedLayout.setCurrentIndex(1)
self.paintImageIndex(0)
self.showMaximized()
if(self.upgradeTrigger == 'level'):
self.setPower((int(self.minPowerToMove)*100)//255)
self.startTime = time.time()
def paintImageIndex(self, imageNumber):
if(self.upgradeTrigger == 'hotspot'):
powerLevel = (self.currentTotalImageNumber/(self.numTotalImages-1))*100
print('power:', powerLevel, ' currentTotalImageNum:', self.currentTotalImageNumber, ' numTotalImages:', self.numTotalImages)
self.setPower(powerLevel)
self.scene.clear()
print('current image number:', imageNumber)
self.nextHotSpotInput = self.hotSpotDict[str(self.currentImageNumber).zfill(6)]
print('nextHotSpotInput', self.nextHotSpotInput)
self.currentPixmap = QPixmap.fromImage(self.imageList[imageNumber]).copy(QRect(0, 0, 1920, 1020)).scaled(self.screen.width(), self.screen.height(), aspectRatioMode=Qt.IgnoreAspectRatio)
self.scene.addPixmap(self.currentPixmap)
self.currentInputModifiers = self.simplifyModifierList(self.nextHotSpotInput['modifiers'])
if(self.nextHotSpotInput['type'] == 'mouse'):
commandString = ''
if self.currentInputModifiers != []:
commandString += 'Press '
for mod in self.currentInputModifiers:
commandString += mod + ' + '
commandString += 'Click '
self.currentMouseButton = self.nextHotSpotInput['button']
if(self.currentMouseButton == 'right'):
pen = QPen(QColor(0, 0, 255, 128))
commandString += 'right mouse button'
elif(self.currentMouseButton == 'left'):
pen = QPen(QColor(255, 0, 0, 128))
commandString += 'left mouse button'
elif(self.currentMouseButton == 'middle'):
pen = QPen(QColor(0, 255, 0, 128))
commandString += 'scroll wheel (middle mouse button)'
else:
pen = QPen(QColor(0, 0, 0, 128))
xScale = self.screen.width()/1920
yScale = self.screen.height()/1020
if(xScale > yScale):
minScale = yScale
else:
minScale = xScale
scaledHotSpotSize = self.hotSpotSize*minScale
xPosition = self.nextHotSpotInput['position'][0]*xScale
yPosition = self.nextHotSpotInput['position'][1]*yScale
# adjust yPosition
yPosition += 30
print('next hotspot pos x %s y %s' % (xPosition, yPosition))
brush = QBrush(QColor(180, 180, 180, 100))
self.currentHotSpot = QGraphicsEllipseItem()
self.currentHotSpot.setRect(xPosition-scaledHotSpotSize/2, yPosition-scaledHotSpotSize/2, scaledHotSpotSize, scaledHotSpotSize)
self.currentHotSpot.setBrush(brush)
self.currentHotSpot.setPen(pen)
self.scene.addItem(self.currentHotSpot)
self.currentInputKey = -1
elif(self.nextHotSpotInput['type'] == 'key'):
# print('key')
self.currentInputKey = self.nextHotSpotInput['scancode']
commandString = 'Press '
for mod in self.currentInputModifiers:
commandString += mod
commandString += ' + '
commandString += self.nextHotSpotInput['name']
self.currentHotSpot = 'not a hotspot'
else:
QMessageBox.critical(self, 'Error: hotSpotInput type is incorrect. got: "'+self.nextHotSpotInput['type']+'" expected: "key" or "mouse"', QMessageBox.Ok)
self.setWindowTitle(self.title + ' ' + commandString)
def playSound(self):
class SoundThread(QThread):
signal = pyqtSignal('PyQt_PyObject')
def __init__(self, soundFilename):
super().__init__()
self.soundFilename = soundFilename
def run(self):
# define stream chunk
chunk = 1024
# open a wav format music
f = wave.open(self.soundFilename, "rb")
# instantiate PyAudio
p = pyaudio.PyAudio()
# open stream
stream = p.open(format=p.get_format_from_width(f.getsampwidth()),
channels=f.getnchannels(),
rate=f.getframerate(),
output=True)
# read data
data = f.readframes(chunk)
# play stream
while data:
stream.write(data)
data = f.readframes(chunk)
# stop stream
stream.stop_stream()
stream.close()
# close PyAudio
p.terminate()
self.signal.emit(soundFilename)
subFolder = ''
if self.folderListNameOnly:
subFolder = '%s%s' % (self.folderListNameOnly[self.currentLevel], os. path.sep)
soundFilename = '%s%s%ssound%s.wav'% (self.folderName, os.path.sep, subFolder, self.currentImageNumber)
if not os.path.isfile(soundFilename):
return
try:
self.soundThread = SoundThread(soundFilename)
self.soundThread.signal.connect(self.soundFinished)
self.soundThread.start()
except:
print('something when wrong with the sound thread')
def soundFinished(self, soundFile):
print('finished playing %s' % soundFile)
def hotSpotClickedHandler(self, itemClicked, modifiers, mouseButton):
print('itemClicked %s, self.currentHotSpot %s, mouseButton %s' % (itemClicked, self.currentHotSpot, mouseButton))
if itemClicked is self.currentHotSpot:
if self.checkModifierMatch(modifiers):
if self.checkButtonMatch(mouseButton):
# print('clicked on hot spot!')
self.playSound()
self.currentImageNumber += 1
self.currentTotalImageNumber += 1
if self.currentImageNumber >= self.numImages:
self.levelCompleted()
else:
self.paintImageIndex(self.currentImageNumber)
else:
# print('wrong mouse button clicked')
pass
else:
# print("modifiers don't match")
pass
else:
# print('wrong spot clicked')
pass
def checkButtonMatch(self, pressedMouseButton):
if pressedMouseButton == Qt.LeftButton:
pressedMouseButtonString = 'left'
if pressedMouseButton == Qt.RightButton:
pressedMouseButtonString = 'right'
if pressedMouseButton == Qt.MiddleButton:
pressedMouseButtonString = 'middle'
return self.currentMouseButton == pressedMouseButtonString
def keyPressedHandler(self, nativeScanCode, keyText, modifiers):
print('scanCode %s, currentInputKey %s' % (nativeScanCode, self.currentInputKey))
if (nativeScanCode == self.currentInputKey) and self.checkModifierMatch(modifiers):
# print('pressed correct key (or key combination)')
self.playSound()
self.currentImageNumber += 1
self.currentTotalImageNumber += 1
if self.currentImageNumber >= self.numImages:
self.levelCompleted()
else:
self.paintImageIndex(self.currentImageNumber)
else:
# print('wrong key or key combination pressed')
pass
def checkModifierMatch(self, pressedModifiers):
modifierTextList = []
if(pressedModifiers & Qt.ShiftModifier):
modifierTextList.append('shift')
if(pressedModifiers & Qt.AltModifier):
modifierTextList.append('alt')
# handle key differences for mac
if(self.platform in ['Windows', 'Linux']):
if(pressedModifiers & Qt.ControlModifier):
modifierTextList.append('ctrl')
if(pressedModifiers & Qt.MetaModifier):
modifierTextList.append('win')
else:
if(pressedModifiers & Qt.ControlModifier):
modifierTextList.append('cmd') # on the mac this is the command key
if(pressedModifiers & Qt.MetaModifier):
modifierTextList.append('ctrl') # on the mac this is the control key
return set(modifierTextList) == set(self.currentInputModifiers)
def simplifyModifierList(self, modifierList):
tempSet = set()
for item in modifierList:
if item == 'left shift':
tempSet.add('shift')
elif item == 'right shift':
tempSet.add('shift')
elif item == 'left ctrl':
tempSet.add('ctrl')
elif item == 'right ctrl':
tempSet.add('ctrl')
elif item == 'left alt':
tempSet.add('alt')
elif item == 'right alt':
tempSet.add('alt')
else:
tempSet.add(item)
return list(tempSet)
def levelCompleted(self):
self.levelTime = time.time()-self.startTime
print('completed level: ', self.currentLevel+1)
if(self.upgradeTrigger == 'level'):
powerLevel = (self.currentLevel/(self.numLevels-1))*100
self.setPower(powerLevel)
timeToBeat = (self.currentTotalImageNumber)*self.timeLimitMultiplier
if(self.currentLevel == self.levelToUnlock):
print('unlockLevel?')
# if the level was completed fast enough to move on
if(self.levelTime <= timeToBeat):
print('levelUnlocked')
# (next level is all levels compounded...)
# if the level completed was the last level
if(self.currentLevel >= self.numLevels-1):
self.gameCompleted()
else:
# move level to unlock up to next level
self.levelToUnlock += 1
# otherwise ask the user if they want to play the next
# level or quit
buttonReply = QMessageBox.question(
self,
'You Beat Level ' + str(self.currentLevel+1),
'You Beat the level!\nYou completed the level in ' + "%.2f" % self.levelTime + ' seconds out of ' + "%.2f" % timeToBeat + '\nPlay next level?',
QMessageBox.Yes | QMessageBox.Cancel)
if(buttonReply == QMessageBox.Cancel):
# quit game and go back to home screen
self.returnToHomeScreen()
else:
# restart (but with next level unlocked)
self.currentLevel = 0
self.currentImageNumber = 0
self.currentTotalImageNumber = 0
self.loadLevel(self.folderList[self.currentLevel])
self.paintImageIndex(0)
else:
print('levelFailed')
# display dialog; complete in X time to advance to next level. Replay? Quit?
buttonReply = QMessageBox.information(self, 'Too Slow...', 'You were not fast enough.\nYou completed the level in ' + "%.2f" % (self.levelTime) + ' seconds\nFinish in ' + "%.2f" % timeToBeat + ' seconds or less to move on.', QMessageBox.Ok | QMessageBox.Cancel)
if(buttonReply == QMessageBox.Cancel):
# quit game and go back to home screen
self.returnToHomeScreen()
else:
# restart
self.currentLevel = 0
self.currentImageNumber = 0
self.currentTotalImageNumber = 0
self.loadLevel(self.folderList[self.currentLevel])
self.paintImageIndex(0)
self.startTime = time.time()
else:
# play next level
self.currentLevel += 1
self.currentImageNumber = 0
self.loadLevel(self.folderList[self.currentLevel])
self.paintImageIndex(0)
def returnToHomeScreen(self):
print('returning to home screen')
self.setWindowTitle(self.title)
self.scene.clear()
self.currentHotSpot = None
self.currentImageNumber = 0
self.currentTotalImageNumber = 0
self.stackedLayout.setCurrentIndex(0)
self.showNormal()
if(self.numLevels > 0):
self.loadLevel(self.folderList[0])
else:
self.loadLevel(self.folderName)
self.currentLevel = 0
def gameCompleted(self):
self.endTime = time.time()
timeToBeat = (self.currentTotalImageNumber)*self.timeLimitMultiplier
self.scene.clear()
self.currentHotSpot = None
self.currentImageNumber = 0
self.currentTotalImageNumber = 0
self.currentPixmap = None
self.currentPixmap = QPixmap.fromImage(self.imageList[self.numImages]).copy(QRect(0, 0, 1920, 1020)).scaled(self.screen.width(), self.screen.height(), aspectRatioMode=Qt.IgnoreAspectRatio)
self.scene.addPixmap(self.currentPixmap)
buttonReply = QMessageBox.information(self, 'You Win!', 'Congradulations, You Won!\nYou completed the game in ' + "%.2f" % (self.endTime-self.startTime) + ' seconds out of ' "%.2f" % timeToBeat, QMessageBox.Ok)
if buttonReply == QMessageBox.Ok:
self.setWindowTitle(self.title)
self.stackedLayout.setCurrentIndex(0)
self.showNormal()
if(self.numLevels > 0):
self.loadLevel(self.folderList[0])
else:
self.loadLevel(self.folderName)
self.currentLevel = 0
def findPorts(self):
ports = list(serial.tools.list_ports.comports())
comPortsList = []
# microcontrollerPort = None
for port in ports:
if 'Silicon Labs' in str(port[1]):
comPortsList.append(port[0])
return comPortsList
def setPower(self, powerLevel):
if(powerLevel > 100):
raise ValueError('powerLevel cannot be set above 100')
if(powerLevel < 0):
raise ValueError('powerLevel cannot be set below 0')
minPower = int(self.minPowerToMove)
mode = self.upgradeMode
leftPower = minPower
rightPower = minPower
maxPower = int(self.maxPowerToMove)
if(mode == "left"):
if(powerLevel <= 50):
leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower)
rightPower = self.interpolate(powerLevel, 0, 50, minPower, maxPower)
else:
leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower)
rightPower = self.interpolate(powerLevel, 50, 100, minPower, maxPower)
elif(mode == "right"):
if(powerLevel <= 50):
rightPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower)
leftPower = self.interpolate(powerLevel, 0, 50, minPower, maxPower)
else:
rightPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower)
leftPower = self.interpolate(powerLevel, 50, 100, minPower, maxPower)
elif(mode == "both"):
leftPower = self.interpolate(powerLevel, 0, 100, minPower, maxPower)
rightPower = leftPower
elif(mode == "distance"):
# add fuel to the robot "tank"
pass
else:
raise ValueError('upgradeMode in config.ini does not match any accepted value')
iLP = int(leftPower)
iRP = int(rightPower)
# desiredPowerLevel -= 45
if self.robot:
print('connected to BaseStation, attempting to set power to', powerLevel, ' L:', leftPower, 'R:', rightPower)
for baseStation in self.robot:
baseStation.write(bytes([0, 0, iLP, iRP])+b'\n')
baseStation.write(bytes([0, 0, iLP, iRP])+b'\n')
else:
print('BaseStation not connected, cannot change power level')
def interpolate(self, inputValue, inputMin, inputMax, outputMin, outputMax):
ratio = (inputValue - inputMin)/(inputMax - inputMin)
outputValue = (outputMax - outputMin) * ratio + outputMin
return outputValue
def closeEvent(self, event):
print('emitting cleanup event')
try:
self.settingsWindow.Abort()
except:
print('ERROR - Could not properly close settings window!')
self.cleanupEvent.emit()
def cleanupStuff(self):
if self.robot:
for baseStation in self.robot:
baseStation.close()
print('closing')
def createReferenceFile(self):
referenceFolder = QFileDialog.getExistingDirectory(self, "Select Folder Location for Reference")
self.startTime = time.time()
if os.path.isdir(referenceFolder):
if(self.numLevels > 0):
# multiLevel game selected
print('multiLevelGame Reference started')
for i in range(0, self.numLevels):
# create folder to hold level in reference file
levelFolderName = referenceFolder+os.path.sep+self.folderListNameOnly[i]
os.mkdir(levelFolderName)
self.loadLevel(self.folderList[i])
# start msmd level
self.stackedLayout.setCurrentIndex(1)
self.showMaximized()
time.sleep(0.2)
for j in range(0, self.numImages):
print('next image: '+str(j))
self.paintImageIndex(j)
QApplication.processEvents()
time.sleep(0.05)
imageName = str(self.currentImageNumber).zfill(6)
pyautogui.screenshot(levelFolderName+os.path.sep+imageName+'.png')
self.currentImageNumber += 1
self.currentTotalImageNumber += 1
self.currentImageNumber = 0
else:
print('singleLevelGame Reference Started')
self.loadLevel(self.folderName)
self.stackedLayout.setCurrentIndex(1)
self.showMaximized()
for j in range(0, self.numImages):
print('next image: '+str(j))
self.paintImageIndex(j)
QApplication.processEvents()
time.sleep(0.05)
imageName = str(self.currentImageNumber).zfill(6)
pyautogui.screenshot(levelFolderName+os.path.sep+imageName+'.png')
self.currentImageNumber += 1
self.currentTotalImageNumber += 1
self.currentImageNumber = 0
self.gameCompleted()
from Calculation import Calculation from SourceData import SourceData from OpticalElementData import OpticalElementData from Settings import Settings sd = SourceData() sd.source_samplingarea = [400e-9, 720e-9] #400 to 720 nm oe = OpticalElementData() se = Settings() calc = Calculation(sd, oe, se) calc.Calculation() calc.Plot_All_SaveAll()
def __init__(self):
Game.__init__(self, Settings().keywords["Titles"]["game-hotpotato"])
self.currentHolder = None
self.stopTimer = {"master": False, "single": False}
def write(self, file=''):
if not file:
file = self.settings.OutputFolder + '/' + self.settings.tersehtml
try:
f = open(file, 'w')
except IOError:
log.critical('Cannot open %s for writing' % (file))
return
f.write(self.insert_HTML_fields())
f.close()
log.debug('Web page %s was updated' % (file))
def insert_HTML_fields(self):
d = {
'JSMolPath': self.settings.JSMolLocation,
'timestamp': self.settings.timestamp,
'JMolPath': self.settings.JmolPath,
'TableBody': self.tableBody,
'JMolWinX': self.settings.JmolWinX,
'JMolWinY': self.settings.JmolWinY,
'jmoloptions': self.settings.JavaOptions,
}
return self.s % d
if __name__ == "__main__":
h = HTML()
from Settings import Settings
h.settings = Settings()
tr = tag('abcd', 'tr')
class Main:
def __init__(self):
self.top = Tk()
self.settings = Settings()
self.server_var = None
self.username_var = None
self.password_var = None
self.connect_window = None
self.text_output = None
self.__logs__ = []
def __confirm_save__(self):
if askyesno(title="Confirm Settings", message="Would you like to save these changes?"):
self.settings.set_login_info(self.username_var.get(), self.password_var.get())
self.settings.set_server_address(self.server_var.get())
self.connect_window.destroy()
def __load_connect_widgets__(self):
frame_top = Frame(self.connect_window)
frame_mid = Frame(self.connect_window)
frame_bot = Frame(self.connect_window)
lbl_server = Label(frame_top, text="Server Address")
lbl_username = Label(frame_mid, text='Username')
lbl_password = Label(frame_bot, text='Password')
entry_server = Entry(frame_top, textvariable=self.server_var, width=50)
entry_username = Entry(frame_mid, textvariable=self.username_var, width=50)
entry_password = Entry(frame_bot, textvariable=self.password_var, exportselection=0, show='*', width=50)
btn_save = Button(self.connect_window, text='Save', command=self.__confirm_save__, width=25, height=5)
btn_cancel = Button(self.connect_window, text='Cancel', command=self.connect_window.destroy, width=25, height=5)
frame_top.pack(side=TOP)
frame_mid.pack(side=TOP)
frame_bot.pack(side=TOP)
lbl_server.pack(side=LEFT)
lbl_username.pack(side=LEFT)
lbl_password.pack(side=LEFT)
entry_server.pack(side=RIGHT, expand=TRUE)
entry_username.pack(side=RIGHT, expand=TRUE)
entry_password.pack(side=RIGHT, expand=TRUE)
btn_save.pack(side=RIGHT)
btn_cancel.pack(side=LEFT)
def __get_log_files__(self):
self.text_output.delete(0.0, 255.255)
self.text_output.insert(INSERT, "Scanning folder for files...\n")
path = self.settings.get_log_path()
logs = [a for a in listdir(path) if isfile(join(path, a))]
self.text_output.insert(INSERT, str(len(logs)) + " files retrieved\n")
self.text_output.insert(INSERT, "Press Upload File(s) to continue\n")
self.__set_logs__(logs)
return logs
def __set_logs__(self, logs):
for i in logs:
self.__logs__.append(self.settings.get_log_path() + "/" + i)
print(self.__logs__)
def __check_settings__(self):
if self.settings.get_log_path() is sys.path[0]:
return "Warning! Log folder path has not been set up. Please change the folder path in settings."
return "Press \"Prepare Files\" to begin"
def __upload_files__(self):
if len(self.__logs__) > 0:
serve = self.settings.get_server_address()
user = self.settings.get_username()
passwo = self.settings.get_password()
upload = FTPConnect(serve, user, passwo)
self.text_output.insert(INSERT, "Attempting to connect...\n")
result = upload.connect()
if result:
self.text_output.insert(INSERT, "Connection Successful!\n")
for log in self.__logs__:
upload.upload_file(log)
self.text_output.insert(INSERT, "Log successfully uploaded.\n")
self.__move_files(upload.new_names)
upload.ftps.close()
else:
self.text_output.insert(INSERT, "Connection has failed!\n")
self.text_output.insert(INSERT, "Check connection settings!\n")
else:
self.text_output.insert(INSERT, "There are no files ready to be uploaded!\n Either press \"Prepare Files\" or check the log folder path settings")
def __move_files(self, new_names):
for i in range(len(self.__logs__)):
os.rename(self.__logs__[i], self.settings.get_processed_folder()+ "/" + new_names[i].replace(" ", "", 1).replace(":", "-"))
self.__logs__.clear()
def run(self):
"""Main Loop"""
frame = Frame(self.top)
bottom_frame = Frame(frame, bg='darkgrey')
settingsbutton = Button(bottom_frame, text='Settings', width=25, height=5, command=self.settings.launch)
connection_button = Button(bottom_frame,text="Connection Settings", width=25, height=5, command=self.connect_settings)
btn_get_files = Button(bottom_frame, text='Prepare Files', width=25, height=5, command=self.__get_log_files__)
uploadbutton = Button(bottom_frame, text='Upload File(s)', width=25, height=5, command=self.__upload_files__)
self.text_output = Text(frame)
self.text_output.insert(0.0, self.__check_settings__())
frame.pack()
bottom_frame.pack(side=BOTTOM, fill=X)
settingsbutton.pack(side=LEFT)
connection_button.pack(side=LEFT)
btn_get_files.pack(side=LEFT)
uploadbutton.pack(side=RIGHT)
self.text_output.pack(side=TOP)
self.top.mainloop()
def connect_settings(self):
"""Loads the connection settings window"""
self.connect_window = Toplevel()
self.connect_window.minsize(500, 100)
self.server_var = StringVar()
self.username_var = StringVar()
self.password_var = StringVar()
self.__load_connect_widgets__()
self.connect_window.grab_set()
self.server_var.set(self.settings.get_server_address())
self.username_var.set(self.settings.get_username())
self.password_var.set(self.settings.get_password())
def UpdateMP(TABLA: str, REMISION: str, DATO_MOD, Value):
engine = create_engine(TABLA, echo=True)
Base.metadata.create_all(bind=engine)
Session = sessionmaker(bind=engine)
session = Session()
valueRef2, ValueWork, ValueProv, ValueReference, ValuePres, ValueRem, ValueNunPre, ValueTotalW, ValueInDate, ValueFinalDate, ValueCode, ValueCoils = SQLMP.FindMP(
TABLA, REMISION)
if DATO_MOD == Settings.Var_Comp26():
session.query(SQLMP).filter_by(Ref2=valueRef2).update(
{SQLMP.Ref2: Value})
elif DATO_MOD == Settings.Var_Comp15():
session.query(SQLMP).filter_by(Worker=ValueWork).update(
{SQLMP.Worker: Value})
elif DATO_MOD == Settings.Var_Comp14():
session.query(SQLMP).filter_by(Provider=ValueProv).update(
{SQLMP.Provider: Value})
elif DATO_MOD == Settings.Var_Comp13():
session.query(SQLMP).filter_by(Reference=ValueReference).update(
{SQLMP.Reference: Value})
elif DATO_MOD == Settings.Var_Comp12():
session.query(SQLMP).filter_by(Presentation=ValuePres).update(
{SQLMP.Presentation: Value})
elif DATO_MOD == Settings.Var_Comp2():
session.query(SQLMP).filter_by(Num_Rem=ValueRem).update(
{SQLMP.Num_Rem: Value})
elif DATO_MOD == Settings.Var_Comp3():
session.query(SQLMP).filter_by(Num_Pre=ValueNunPre).update(
{SQLMP.Num_Pre: Value})
elif DATO_MOD == Settings.Var_Comp4():
session.query(SQLMP).filter_by(Total_Weight=ValueTotalW).update(
{SQLMP.Total_Weight: Value})
elif DATO_MOD == Settings.Var_Comp19():
session.query(SQLMP).filter_by(Initial_Date=ValueInDate).update(
{SQLMP.Initial_Date: Value})
elif DATO_MOD == Settings.Var_Comp20():
session.query(SQLMP).filter_by(Final_Date=ValueFinalDate).update(
{SQLMP.Final_Date: Value})
elif DATO_MOD == Settings.Var_Comp1():
session.query(SQLMP).filter_by(Code=ValueCode).update(
{SQLMP.Code: Value})
elif DATO_MOD == Settings.Var_Comp6():
session.query(SQLMP).filter_by(Num_Coils=ValueCoils).update(
{SQLMP.Num_Coils: Value})
session.commit()
session.close()
class CNN_Vis_Demo_Model(QObject):
# These indices are used to notify the view about the changes
data_idx_model_names = 0
data_idx_layer_names = 1
data_idx_layer_output_sizes = 2
data_idx_layer_activation = 3
data_idx_probs = 4
data_idx_input_image_names = 5
data_idx_input_image = 6
data_idx_labels = 7
data_idx_new_input = 128
data_idx_input_image_path = 8
dataChanged = pyqtSignal(int)
settings = None
class BackpropModeOption(Enum):
GRADIENT = 'Gradient'
ZF = 'ZF Deconv'
GUIDED = 'Guided Backprop'
def __init__(self):
super(QObject, self).__init__()
self.settings = Settings() # Read settings from files
self.caffevis_caffe_root = self.settings.caffevis_caffe_root
sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python'))
import caffe
if self.settings.use_GPU:
caffe.set_mode_gpu()
caffe.set_device(self.settings.gpu_id)
print('Loaded caffe in GPU mode, using device', self.settings.gpu_id)
else:
caffe.set_mode_cpu()
print('Loaded caffe in CPU mode')
self.camera_id = self.settings.camera_id
self.cap = cv2.VideoCapture(self.camera_id)
self._layer_list = [] # to be read from prototxt
self._layer_output_sizes = {} # to be read from prototxt
self.online = False # indicates if the network has finished classifying an image
def set_model(self, model_name):
"""
set the network model
:param model_name:
:return:
"""
if self.settings.model_names.__contains__(model_name):
self.settings.load_settings(model_name)
self.online = False
self.load_net(model_name)
def load_net(self, model_name):
sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python'))
import caffe
self._model_name = model_name
self._model_def = self.settings.prototxt
self._model_weights = self.settings.network_weights
self._labels = np.loadtxt(self.settings.label_file, str, delimiter='\n')
processed_prototxt = self._process_network_proto(self._model_def) # enable deconvolution
self._net = caffe.Classifier(processed_prototxt, self._model_weights, mean=self.settings.mean, raw_scale=255.0,
channel_swap=self.settings.channel_swap)
current_input_shape = self._net.blobs[self._net.inputs[0]].shape
current_input_shape[0] = 1
self._net.blobs[self._net.inputs[0]].reshape(*current_input_shape)
self._net.reshape()
self._get_layers_info()
self.dataChanged.emit(self.data_idx_layer_names)
# get the names of demo-images
self._input_image_names = [image_name for image_name in os.listdir(self.settings.input_image_path)]
self.dataChanged.emit(self.data_idx_input_image_names)
self._transformer = caffe.io.Transformer(
{self._data_blob_name: self._net.blobs[self._data_blob_name].data.shape})
self._transformer.set_transpose(self._data_blob_name, (2, 0, 1)) # move image channels to outermost dimension
self._transformer.set_mean(self._data_blob_name,
self.settings.mean) # subtract the dataset-mean value in each channel
self._transformer.set_raw_scale(self._data_blob_name, 255) # rescale from [0, 1] to [0, 255]
self._transformer.set_channel_swap(self._data_blob_name, self.settings.channel_swap)
def set_input_and_forward(self, input_image_name, video=False):
"""
use static image file or camera as input to forward the network.
View will be informed to resfresh the content.
If video is set, input_image_name will be ignored.
:param input_image_name: The file name of the local image file
:param video: set True to use camera as input
"""
sys.path.insert(0, os.path.join(self.caffevis_caffe_root, 'python'))
import caffe
def _forward_image(_image):
input_image = caffe.io.resize(_image, self._input_dims, mode='constant', cval=0)
self._input_image = (input_image * 255).astype(np.uint8)
transformed_image = self._transformer.preprocess(self._data_blob_name, input_image)
self._net.blobs[self._data_blob_name].data[...] = transformed_image
self._net.forward()
self.online = True
self.dataChanged.emit(self.data_idx_new_input)
def _square(_image):
"""
adjust image dimensions so that the image will be expanded to the largest side padding order: top, bottom, left, right
:param _image: image to be processed
:return: processed image
"""
[height, width, _] = _image.shape
# icon portrait mode
if width < height:
pad_size = height - width
if pad_size % 2 == 0:
icon_squared = cv2.copyMakeBorder(_image, 0, 0, pad_size / 2, pad_size / 2, cv2.BORDER_CONSTANT,
value=[0, 0, 0])
else:
icon_squared = cv2.copyMakeBorder(_image, 0, 0, pad_size / 2 + 1, pad_size / 2, cv2.BORDER_CONSTANT,
value=[0, 0, 0])
return icon_squared
# icon landscape mode
elif height < width:
pad_size = width - height
if pad_size % 2 == 0:
# top, bottom, left, right
icon_squared = cv2.copyMakeBorder(_image, pad_size / 2, pad_size / 2, 0, 0, cv2.BORDER_CONSTANT,
value=[0, 0, 0])
else:
icon_squared = cv2.copyMakeBorder(_image, pad_size / 2 + 1, pad_size / 2, 0, 0, cv2.BORDER_CONSTANT,
value=[0, 0, 0])
return icon_squared
elif height == width:
return _image
def _crop_max_square(_image):
"""
crop the biggest square at the center of a image
:param _image: image to be processed
:return: processed image
"""
h, w, c = _image.shape
l = min(h, w)
if (h + l) % 2 != 0:
_image = _image[(h - l + 1) / 2:(h + l + 1) / 2, :, :]
elif (w + l) % 2 != 0:
_image = _image[:, (w - l + 1) / 2:(w + l + 1) / 2, :]
else:
_image = _image[(h - l) / 2:(h + l) / 2, (w - l) / 2:(w + l) / 2, :]
return _image
if video:
ret, frame = self.cap.read()
squared_image = _crop_max_square(frame)
_forward_image(cv2.flip(squared_image[:, :, (2, 1, 0)], 1)) # RGB
else:
if self._input_image_names.__contains__(input_image_name):
self._input_image_path = os.path.join(self.settings.input_image_path, input_image_name)
image = caffe.io.load_image(self._input_image_path) # RGB
image = _square(image)
_forward_image(image)
def get_data(self, data_idx):
"""
Use the data index to get the data.
The intend was to add control logic in access. But, this seems to be useless.
:param data_idx:
:return: Desired data
"""
if data_idx == self.data_idx_model_names:
return self.settings.model_names
elif data_idx == self.data_idx_layer_names:
return self._layer_list
elif data_idx == self.data_idx_layer_output_sizes:
return self._layer_output_sizes
elif data_idx == self.data_idx_probs:
return self._net.blobs[self._props_blob_name].data.flatten()
elif data_idx == self.data_idx_input_image_names:
return self._input_image_names
elif data_idx == self.data_idx_labels:
return self._labels
elif data_idx == self.data_idx_input_image_path:
return self._input_image_path
elif data_idx == self.data_idx_input_image:
return self._input_image
def get_activations(self, layer_name):
"""
Get all the activations of one layer
:param layer_name:
:return: activations (N, H, W)
"""
if self.online and self._layer_list.__contains__(layer_name):
activations = self._net.blobs[layer_name].data[0]
return activations
def get_activation(self, layer_name, unit_index):
"""
Get the activation of a neuron
:param layer_name:
:return: activations (H, W)
"""
if self.online and self._layer_list.__contains__(layer_name) and unit_index < \
self._layer_output_sizes[layer_name][0]:
activation = self._net.blobs[layer_name].data[0][unit_index]
return activation
def get_top_k_images_of_unit(self, layer_name, unit_index, k, get_deconv):
"""
Get k images with highest acivation to one certain neuron.
:param layer_name:
:param unit_index:
:param k:
:param get_deconv: Get the deconv results of the top images
:return: Desired top k images
"""
if self.online and self.settings.deepvis_outputs_path and self._layer_list.__contains__(layer_name) \
and unit_index < self._layer_output_sizes[layer_name][0]:
unit_dir = os.path.join(self.settings.deepvis_outputs_path, layer_name, 'unit_%04d' % unit_index)
assert k <= 9
if get_deconv:
type = 'deconvnorm'
else:
type = 'maxim'
pixmaps = []
for i in range(k):
file_name = '%s_%03d.png' % (type, i)
file_path = os.path.join(unit_dir, file_name)
if os.path.exists(file_path):
pixmaps.append(QPixmap(file_path))
else:
print(file_path + " not exists.")
return pixmaps
def get_top_1_images_of_layer(self, layer_name):
"""
Get the top 1 images of all units in one layers
:param layer_name:
:return: The images with highest activations to the units
"""
if self.online and self.settings.deepvis_outputs_path and self._layer_list.__contains__(layer_name):
channel_number = self._layer_output_sizes[layer_name][0]
pixmaps = []
for unit_index in range(channel_number):
unit_dir = os.path.join(self.settings.deepvis_outputs_path, layer_name, 'unit_%04d' % unit_index)
file_name = 'maxim_000.png'
file_path = os.path.join(unit_dir, file_name)
pixmaps.append(QPixmap(file_path))
return pixmaps
def get_deconv(self, layer_name, unit_index, backprop_mode):
"""
Compute the backprop/deconv of one unit
:param layer_name:
:param unit_index:
:param backprop_mode: Avaliable options: self.BackpropModeOption
:return: result
"""
diffs = self._net.blobs[layer_name].diff[0]
diffs = diffs * 0
data = self._net.blobs[layer_name].data[0]
diffs[unit_index] = data[unit_index]
diffs = np.expand_dims(diffs, 0) # add batch dimension
layer_name = str(layer_name)
if backprop_mode == self.BackpropModeOption.GRADIENT.value:
result = self._net.backward_from_layer(layer_name, diffs, zero_higher=True)
elif backprop_mode == self.BackpropModeOption.ZF.value:
result = self._net.deconv_from_layer(layer_name, diffs, zero_higher=True, deconv_type='Zeiler & Fergus')
elif backprop_mode == self.BackpropModeOption.GUIDED.value:
result = self._net.deconv_from_layer(layer_name, diffs, zero_higher=True, deconv_type='Guided Backprop')
else:
result = None
if result is not None:
result = np.transpose(result[self._net.inputs[0]][0], (1, 2, 0))
return result
def _process_network_proto(self, prototxt):
processed_prototxt = prototxt + ".processed_by_deepvis"
# check if force_backwards is missing
found_force_backwards = False
with open(prototxt, 'r') as proto_file:
for line in proto_file:
fields = line.strip().split()
if len(fields) == 2 and fields[0] == 'force_backward:' and fields[1] == 'true':
found_force_backwards = True
break
# write file, adding force_backward if needed
with open(prototxt, 'r') as proto_file:
with open(processed_prototxt, 'w') as new_proto_file:
if not found_force_backwards:
new_proto_file.write('force_backward: true\n')
for line in proto_file:
new_proto_file.write(line)
# run upgrade tool on new file name (same output file)
upgrade_tool_command_line = self.caffevis_caffe_root + '/build/tools/upgrade_net_proto_text.bin ' + processed_prototxt + ' ' + processed_prototxt
os.system(upgrade_tool_command_line)
return processed_prototxt
def switch_camera(self, on):
if on:
self.cap.open(self.camera_id)
else:
self.cap.release()
def _get_layers_info(self):
"""
Get the layer names / output sizes / 'data' blob name / input dimension
:return:
"""
self._layer_list = []
self._layer_output_sizes = {}
# go over layers
all_layer_list = list(self._net._layer_names)
total_layer_number = len(all_layer_list)
for idx in range(total_layer_number):
layer_name = all_layer_list[idx]
# skip input, output and inplace layers. eg. relu
if idx == 0 or idx == total_layer_number - 1 or (
len(self._net.top_names[layer_name]) == 1 and len(self._net.bottom_names[layer_name]) == 1 and
self._net.top_names[layer_name][0] == self._net.bottom_names[layer_name][0]):
continue
self._layer_list.append(layer_name)
# get layer output size
top_shape = self._net.blobs[layer_name].data[0].shape
self._layer_output_sizes.update({layer_name: top_shape})
# get data blob name
self._data_blob_name = self._net.top_names[all_layer_list[0]][0]
# get input dims
self._input_dims = self._net.blobs[self._data_blob_name].data.shape[2:4]
# get prob blob name
self._props_blob_name = self._net.top_names[all_layer_list[-1]][0]
PB = E.CyPitboss()
gc = E.CyGlobalContext()
LT = E.CyTranslator()
# Add Altroot python folder as import path
pythonDir = os.path.join(gc.getAltrootDir(), '..', 'Python', 'v8')
if pythonDir not in sys.path:
sys.path.append(pythonDir)
from Settings import Settings
import FindHash
from WebserverActions import Action_Handlers, createGameData \
, gen_answer \
#, getListOfSaves, getSaveFolder
PbSettings = Settings() #.instance()
class HTTPRequestHandler(BaseHTTPRequestHandler):
"""The do_POST method of this class handle the control commands
of the webinterface
"""
def log_message(self, _format, *args):
"Redefine is ness. to omit python error popups!!"
return
def check_password(self, input_pw):
if input_pw == PbSettings['webserver']['password']:
return True
def __init__(self, settings_bin_path, device, show_progressbar,
input_adc_array, out_array_mean, out_array_sigma,
out_array_is_ped, out_array_is_hit, out_array_is_seed,
out_array_chs_cm, out_array_cm, out_array_mean_cmc,
out_array_sigma_cmc, out_array_is_ped_cmc,
out_array_is_hit_cmc, out_array_is_seed_cmc, det_index):
mp.Process.__init__(self)
print 'Creating PedestalCalculations instance'
self.show_pb = show_progressbar
self.settings = Settings()
self.device = device
self.do_cmc = self.settings.do_cmc and (self.device == 'dut')
self.LoadSettingsBinary(settings_bin_path)
self.out_dir = self.settings.output_dir
self.sub_dir = self.settings.sub_dir
self.file_name = self.settings.file_name
self.tree_name = self.settings.tree_name
self.slide_leng = self.settings.sliding_length
self.run_no = self.settings.run
self.ana_events = self.settings.ana_events
self.ped_branches = [
'diaPed', 'diaPedSigma', 'cm', 'diaPedCmc', 'diaPedSigmaCmc',
'diaSignal', 'diaSignalCmc'
]
self.raw_tel_branches_dic = {
0: 'D0X_ADC',
1: 'D0Y_ADC',
2: 'D1X_ADC',
3: 'D1Y_ADC',
4: 'D2X_ADC',
5: 'D2Y_ADC',
6: 'D3X_ADC',
7: 'D3Y_ADC'
}
self.device_to_position = {
'telx0': 0,
'tely0': 1,
'telx1': 2,
'tely1': 3,
'telx2': 4,
'tely2': 5,
'telx3': 6,
'tely3': 7
}
self.raw_dut_branch = 'DiaADC'
self.rootFile = ro.TFile()
self.rootTree = ro.TTree()
self.utils = Utils()
self.dest_path_stem = self.out_dir + '/' + self.sub_dir + '/' + str(
self.run_no) + '/' + self.device
self.read_branch = self.raw_tel_branches_dic[
0] if self.device == 'telx0' else self.raw_tel_branches_dic[
1] if self.device == 'tely0' else self.raw_tel_branches_dic[
2] if self.device == 'telx1' else self.raw_tel_branches_dic[
3] if self.device == 'tely1' else self.raw_tel_branches_dic[
4] if self.device == 'telx2' else self.raw_tel_branches_dic[
5] if self.device == 'tely2' else self.raw_tel_branches_dic[
6] if self.device == 'telx3' else self.raw_tel_branches_dic[
7] if self.device == 'tely3' else self.raw_dut_branch
self.hit_factor = self.settings.clust_hit[
0] if self.device == 'telx0' else self.settings.clust_hit[
1] if self.device == 'tely0' else self.settings.clust_hit[
2] if self.device == 'telx1' else self.settings.clust_hit[
3] if self.device == 'tely1' else self.settings.clust_hit[
4] if self.device == 'telx2' else self.settings.clust_hit[
5] if self.device == 'tely2' else self.settings.clust_hit[
6] if self.device == 'telx3' else self.settings.clust_hit[
7] if self.device == 'tely3' else self.settings.clust_hit[
8]
self.seed_factor = self.settings.clust_seed[
0] if self.device == 'telx0' else self.settings.clust_seed[
1] if self.device == 'tely0' else self.settings.clust_seed[
2] if self.device == 'telx1' else self.settings.clust_seed[
3] if self.device == 'tely1' else self.settings.clust_seed[
4] if self.device == 'telx2' else self.settings.clust_seed[
5] if self.device == 'tely2' else self.settings.clust_seed[
6] if self.device == 'telx3' else self.settings.clust_seed[
7] if self.device == 'tely3' else self.settings.clust_seed[
8]
self.np_type = self.settings.dut_np_data_type if self.device == 'dut' else self.settings.tel_np_data_type
self.chs = self.settings.dutDetChs if self.device == 'dut' else self.settings.telDetChs
# Numpy arrays for the calculations
self.device_ADC_mean = np.zeros((self.chs, self.ana_events),
dtype='float32')
self.device_ADC_sigma = np.zeros((self.chs, self.ana_events),
dtype='float32')
self.device_ADC_is_ped = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_ADC_is_hit = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_ADC_is_seed = np.zeros((self.chs, self.ana_events),
dtype='?')
if self.do_cmc:
self.device_channels_cm = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_cm = np.zeros(self.ana_events, dtype='float32')
self.device_ADC_mean_cmc = np.zeros((self.chs, self.ana_events),
dtype='float32')
self.device_ADC_sigma_cmc = np.zeros((self.chs, self.ana_events),
dtype='float32')
self.device_is_cm = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_is_ped_cmc = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_is_hit_cmc = np.zeros((self.chs, self.ana_events),
dtype='?')
self.device_is_seed_cmc = np.zeros((self.chs, self.ana_events),
dtype='?')
# Numpy arrays for event based calculations
self.adc = np.zeros(self.chs, dtype=self.np_type)
self.mean = np.zeros(self.chs, dtype='float32')
self.sigma = np.zeros(self.chs, dtype='float32')
self.mean_sq = np.zeros(self.chs, dtype='float32')
self.elem = np.zeros(self.chs, dtype='uint16')
if self.do_cmc:
self.cm = np.zeros(1, dtype='float32')
self.adc_cmc = np.zeros(self.chs, dtype='float32')
self.mean_cmc = np.zeros(self.chs, dtype='float32')
self.sigma_cmc = np.zeros(self.chs, dtype='float32')
self.mean_sq_cmc = np.zeros(self.chs, dtype='float32')
self.elem_cmc = np.zeros(self.chs, dtype='uint16')
# channels that are masked for common mode calculation because they are screened or noisy
self.is_not_masked = np.ones(
self.chs, '?') if self.device.startswith('tel') else np.array([
ch not in set(self.settings.noisy)
| set(self.settings.screened) for ch in xrange(self.chs)
], '?')
# global variables passed as reference for shared memory ctype vectors
global in_adc_array, out_array_m, out_array_s, out_array_is_p, out_array_is_h, out_array_is_s
in_adc_array = input_adc_array
out_array_m = out_array_mean
out_array_s = out_array_sigma
out_array_is_h = out_array_is_hit
out_array_is_s = out_array_is_seed
out_array_is_p = out_array_is_ped
self.det_index = det_index
if self.do_cmc:
global out_array_chs_c, out_array_c, out_array_mean_cm, out_array_sigma_cm, out_array_is_ped_cm, out_array_is_hit_cm, out_array_is_seed_cm
out_array_chs_c = out_array_chs_cm
out_array_c = out_array_cm
out_array_mean_cm = out_array_mean_cmc
out_array_sigma_cm = out_array_sigma_cmc
out_array_is_ped_cm = out_array_is_ped_cmc
out_array_is_hit_cm = out_array_is_hit_cmc
out_array_is_seed_cm = out_array_is_seed_cmc
if self.device.startswith('tel'):
self.device_ADC_all = np.ctypeslib.as_array(
in_adc_array.get_obj())[self.det_index]
else:
self.device_ADC_all = np.ctypeslib.as_array(in_adc_array.get_obj())
