def __init__(self, rootdir, start_port):
self.rootdir = os.path.expanduser(rootdir)
self.repodir = os.path.join(self.rootdir, 'repositories')
self.builddir = os.path.join(self.rootdir, 'builds')
self.releasedir = os.path.join(self.rootdir, 'releases')
self.exportdir = os.path.join(self.rootdir, 'exports')
self.logdir = os.path.join(self.rootdir, 'logs')
self.piddir = os.path.join(self.rootdir, 'pids')
self.start_port = start_port
paths = [
self.rootdir, self.repodir, self.builddir, self.releasedir,
self.exportdir, self.logdir, self.piddir
]
for path in paths:
if not os.path.exists(path):
mkpath(path)
# Note that this means TinyservManager is a singleton for now...
ProcessManager.init(self.piddir)
self.projects = {}
for reponame in os.listdir(self.repodir):
self.projects[reponame] = Project(self, reponame)
def remove_service(self, sm_config):
print 'Removing', sm_config.config_name
config_dir = self.processmgr.SERIAL_MUX_CONFIG_DIR
# remove daemon/service
self.processmgr.remove(sm_config.config_name)
self.model.remove(sm_config.config_name)
# remove config
ProcessManager.remove_config(config_dir, sm_config.config_name)
# update UI
self.ui.update(self.model)
def create_service(self):
config_dir = self.processmgr.SERIAL_MUX_CONFIG_DIR
# create config
config_name = SerialMuxConfigs.find_available_name(config_dir)
self.model.add(config_name)
ProcessManager.create_config(config_dir, config_name)
# create daemon/service
self.processmgr.create(config_name)
# update UI
self.ui.update(self.model)
class ExplorerManager(threading.Thread):
applications_dict = {}
def __init__(self):
threading.Thread.__init__(self)
self.processManager = ProcessManager()
self.path = None
#win32gui.SystemParametersInfo(win32con.SPI_SETFOREGROUNDLOCKTIMEOUT, 0, win32con.SPIF_SENDWININICHANGE | win32con.SPIF_UPDATEINIFILE)
def winEnumHandler( self, hwnd, ctx ):
if win32gui.IsWindowVisible( hwnd ):
# get the proccessid from the windowhandle
processID = win32process.GetWindowThreadProcessId(hwnd)[1]
processName = self.processManager.EnumProcesses(processID)
windowTitle = win32gui.GetWindowText( hwnd )
if processName and processName.lower() == APPLICATION_NAME and self.path in windowTitle:
if processName.lower() in self.applications_dict.keys():
self.applications_dict[processName.lower()].append( windowTitle )
else:
self.applications_dict[processName.lower()] = [ windowTitle ]
def begin(self,folder):
while True:
self.applications_dict.clear()
self.path = folder.split('\\')[-1]
win32gui.EnumWindows( self.winEnumHandler, None )
#print '-'*78
if len(self.applications_dict) == 1:
print self.applications_dict
return "folder open"
def RunBurnin(ModelType,modelvals,modelPopNames,resultsName,PopulationParameters,DiseaseParameters,endTime,mprandomseed,stepLength=1,writefolder='',startDate=datetime(2020,2,1),fitdates=[],hospitalizations=[],deaths=[],cases=[],fitper=.3,FolderContainer='',saveRun=False,historyData={},SavedRegionFolder=ParameterSet.SavedRegionFolder,burnin=True,vaccinationdata={}):
if saveRun:
if not os.path.exists(os.path.join(SavedRegionFolder,FolderContainer)):
os.makedirs(os.path.join(SavedRegionFolder,FolderContainer))
cleanUp(modelPopNames)
print("RunBurnin: TransProb_AH Len:",len(DiseaseParameters['TransProb_AH']))
PopulationData, GlobalInteractionMatrix, HospitalTransitionRate, HospitalNames, GlobalLocations, LocationImportationRisk = modelSetup(ModelType,modelvals,PopulationParameters,DiseaseParameters)
ParameterVals = PopulationParameters
ParameterVals.update(DiseaseParameters)
RegionalList, timeRange, fitinfo = ProcessManager.RunModel(GlobalLocations, GlobalInteractionMatrix, HospitalTransitionRate,LocationImportationRisk,PopulationParameters,DiseaseParameters,endTime,resultsName,mprandomseed,startDate=startDate,modelPopNames=modelPopNames,fitdates=fitdates,hospitalizations=hospitalizations,deaths=deaths,cases=cases,fitper=fitper,burnin=burnin,FolderContainer=FolderContainer,saveRun=saveRun,historyData=historyData,SavedRegionFolder=SavedRegionFolder,vaccinationdata=vaccinationdata)
if saveRun and fitinfo['fitted']:
PostProcessing.WriteFitvals(resultsName,ModelType,fitinfo['SLSH'], fitinfo['SLSD'], fitinfo['SLSC'], fitinfo['avgperdiffhosp'], fitinfo['avgperdiffdeaths'], fitinfo['avgperdiffcases'],writefolder)
Utils.PickleFileWrite(os.path.join(SavedRegionFolder,FolderContainer,"PopulationParameters.pickle"), PopulationParameters)
Utils.PickleFileWrite(os.path.join(SavedRegionFolder,FolderContainer,"DiseaseParameters.pickle"), DiseaseParameters)
else:
if os.path.exists(os.path.join(SavedRegionFolder,FolderContainer)):
os.rmdir(os.path.join(SavedRegionFolder,FolderContainer))
cleanUp(modelPopNames,len(RegionalList))
if os.path.exists(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle")):
os.remove(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle"))
return fitinfo
def _on_release_updated(self):
if not self.release.get('cmdline'):
return
args = self.release['cmdline'].split()
env = {}
env.update({'PORT': str(self.release['port'])})
env.update(self.release.get('env', {}))
self.process = ProcessManager.Process(
name=self.name,
desc=self.release.get('description') or "project %s" % self.name,
program=args[0],
args=args[1:],
workingDir=self.builddir,
logFile=self.logfile,
env=env)
ProcessManager.set(self.process)
def _on_release_updated(self):
if not self.release.get('cmdline'):
return
args = self.release['cmdline'].split()
env = {}
env.update({'PORT': str(self.release['port'])})
env.update(self.release.get('env', {}))
self.process = ProcessManager.Process(
name=self.name,
desc=self.release.get('description') or "project %s" % self.name,
program=args[0],
args=args[1:],
workingDir=self.builddir,
logFile=self.logfile,
env=env
)
ProcessManager.set(self.process)
def UserInterActivate():
while (True):
print(g_Title),
iIndex = raw_input()
if iIndex == '1':
ProcessManager.Run()
elif iIndex == '2':
CollectData.AnalyzeLog()
elif iIndex == "q":
break
else:
print(u"输入参数不正确,请输入[1-3之内的数值]")
print ""
def __init__(self):
self.objects = []
self.running = 1
self.checkArgs()
self.config = init_config()
init_pygame(self)
init_opengl(self)
if self.args['disableSound']:
self.sound = None
else:
from sound import *
self.sound = CSound(self, self.config.getint('Sound','Frequency'), True)
self.player = Player(sound = self.sound)
self.physics = Physics(self)
self.octree = self.physics.octree
self.graphics = Graphics(self)
self.input = Input(self)
self.objects.append(self.player)
self.input_thread = InputThread(self.input)
self.input_thread.start()
self.networkThread = network.NetworkThread(self)
self.process_manager = ProcessManager()
self.state_manager = StateManager()
self.trigger_manager = TriggerManager(self)
self.menu = Menu(self)
self.state_manager.push(self.quit, None)
self.state_manager.push(self.menu.menu_is_open, None)
self.state_manager.process(None)
self.physics.updateObjects(self.objects)
self.fpsTime = time.time()
# TODO: Don't ask me, iam an alien
self.trigger_manager.Ugly_Function_For_Loading_Main_Keytriggers()
self.showPlayerList = False
def __init__(self, rootdir, start_port):
self.rootdir = os.path.expanduser(rootdir)
self.repodir = os.path.join(self.rootdir, 'repositories')
self.builddir = os.path.join(self.rootdir, 'builds')
self.releasedir = os.path.join(self.rootdir, 'releases')
self.exportdir = os.path.join(self.rootdir, 'exports')
self.logdir = os.path.join(self.rootdir, 'logs')
self.piddir = os.path.join(self.rootdir, 'pids')
self.start_port = start_port
paths = [self.rootdir, self.repodir, self.builddir, self.releasedir,
self.exportdir, self.logdir, self.piddir]
for path in paths:
if not os.path.exists(path):
mkpath(path)
# Note that this means TinyservManager is a singleton for now...
ProcessManager.init(self.piddir)
self.projects = {}
for reponame in os.listdir(self.repodir):
self.projects[reponame] = Project(self, reponame)
def RunSavedRegionModelType(ModelType,modelvals,modelPopNames,resultsName,PopulationParameters,DiseaseParameters,endTime,mprandomseed,stepLength=1,writefolder='',startDate=datetime(2020,2,1),SavedRegionFolder='',numregions=-1,FolderContainer='',vaccinationdata={}):
cleanUp(modelPopNames)
ParameterVals = PopulationParameters
ParameterVals.update(DiseaseParameters)
PopulationData, GlobalInteractionMatrix, HospitalTransitionRate, HospitalNames, GlobalLocations, LocationImportationRisk = modelSetup(ModelType,modelvals,PopulationParameters,DiseaseParameters)
RegionalList, timeRange, fitinfo = ProcessManager.RunModel(GlobalLocations, GlobalInteractionMatrix, HospitalTransitionRate,LocationImportationRisk,PopulationParameters,DiseaseParameters,endTime,resultsName,mprandomseed,startDate=startDate,modelPopNames=modelPopNames,SavedRegionFolder=SavedRegionFolder,numregions=numregions,FolderContainer=FolderContainer,vaccinationdata=vaccinationdata)
if fitinfo['fitted']:
PostProcessing.WriteFitvals(resultsName,ModelType,fitinfo['SLSH'], fitinfo['SLSD'], fitinfo['SLSC'], fitinfo['avgperdiffhosp'], fitinfo['avgperdiffdeaths'], fitinfo['avgperdiffcases'],writefolder)
PostProcessing.WriteParameterVals(resultsName,ModelType,ParameterVals,writefolder)
results = PostProcessing.CompileResults(resultsName,modelPopNames,RegionalList,timeRange)
PostProcessing.WriteAggregatedResults(results,ModelType,resultsName,modelPopNames,RegionalList,HospitalNames,endTime,writefolder)
cleanUp(modelPopNames,len(RegionalList))
if os.path.exists(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle")):
os.remove(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle"))
return fitinfo
def RunDefaultModelType(ModelType,modelvals,modelPopNames,resultsName,PopulationParameters,DiseaseParameters,endTime,mprandomseed,stepLength=1,writefolder='',startDate=datetime(2020,2,1),fitdates=[],hospitalizations=[],deaths=[],cases=[],fitper=.3,StartInfected=-1,historyData={},vaccinationdata={}):
cleanUp(modelPopNames)
ParameterVals = PopulationParameters
ParameterVals.update(DiseaseParameters)
PopulationData, GlobalInteractionMatrix, HospitalTransitionRate, HospitalNames, GlobalLocations, LocationImportationRisk = modelSetup(ModelType,modelvals,PopulationParameters,DiseaseParameters)
RegionalList, timeRange, fitinfo = ProcessManager.RunModel(GlobalLocations, GlobalInteractionMatrix, HospitalTransitionRate,LocationImportationRisk,PopulationParameters,DiseaseParameters,endTime,resultsName,mprandomseed,startDate=startDate,stepLength=1,numregions=-1,modelPopNames=modelPopNames,fitdates=fitdates,hospitalizations=hospitalizations,deaths=deaths,cases=cases,fitper=fitper,burnin=False,StartInfected=StartInfected,historyData=historyData,vaccinationdata=vaccinationdata)
PostProcessing.WriteParameterVals(resultsName,ModelType,ParameterVals,writefolder)
results = PostProcessing.CompileResults(resultsName,modelPopNames,RegionalList,timeRange)
PostProcessing.WriteAggregatedResults(results,ModelType,resultsName,modelPopNames,RegionalList,HospitalNames,endTime,writefolder)
cleanUp(modelPopNames,len(RegionalList))
if os.path.exists(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle")):
os.remove(os.path.join(ParameterSet.ResultsFolder,"Results_"+resultsName+".pickle"))
return fitinfo
class CaveOfDanger:
def __init__(self):
self.objects = []
self.running = 1
self.checkArgs()
self.config = init_config()
init_pygame(self)
init_opengl(self)
if self.args['disableSound']:
self.sound = None
else:
from sound import *
self.sound = CSound(self, self.config.getint('Sound','Frequency'), True)
self.player = Player(sound = self.sound)
self.physics = Physics(self)
self.octree = self.physics.octree
self.graphics = Graphics(self)
self.input = Input(self)
self.objects.append(self.player)
self.input_thread = InputThread(self.input)
self.input_thread.start()
self.networkThread = network.NetworkThread(self)
self.process_manager = ProcessManager()
self.state_manager = StateManager()
self.trigger_manager = TriggerManager(self)
self.menu = Menu(self)
self.state_manager.push(self.quit, None)
self.state_manager.push(self.menu.menu_is_open, None)
self.state_manager.process(None)
self.physics.updateObjects(self.objects)
self.fpsTime = time.time()
# TODO: Don't ask me, iam an alien
self.trigger_manager.Ugly_Function_For_Loading_Main_Keytriggers()
self.showPlayerList = False
def checkArgs(self):
self.args = {'disableWater': False,
'disableSound': False,
'host': None,
'port': 30000}
if sys.platform == "win32":
self.args['disableSound'] = True
if len(sys.argv) > 1:
for index, arg in enumerate(sys.argv):
if arg == "--help" or arg == "-h":
print "Arguments: \n"\
" --nowater Disable water\n"\
" --nosound Disable sound\n"\
" --host Connect to host\n"\
" --port Port (Default: 30000)\n"
sys.exit(0)
elif arg == "--nowater":
self.args['disableWater'] = True
elif arg == "--nosound":
self.args['disableSound'] = True
elif arg == "--host":
if not len(sys.argv) > index + 1:
print "No host specified for --host"
continue
self.args['host'] = sys.argv[index + 1]
elif arg == "--port":
if not len(sys.argv) > index + 1:
print "No port specified for --port"
continue
self.args['port'] = int(sys.argv[index + 1])
def run(self):
while self.running:
self.state_manager.process(None)
self.process_manager.process(None)
#pygame.time.wait(60)
del self.sound
self.input.running = False
self.networkThread.running = False
#test_process()
#test_states()
def quit(self, caller, purpose):
if purpose is "STOP_PURPOSE":
print "quit stopping"
self.running = 0
elif purpose is "INIT_PURPOSE":
pass
elif purpose is "FRAME_PURPOSE":
self.running = 0
else:
print "quit: no purpose"
def runGame(self, caller, purpose):
if purpose is "STOP_PURPOSE":
print "game stopping"
elif purpose is "INIT_PURPOSE":
print "game starting"
self.graphics.initGL()
terrain = "data/model/terrain.obj"
self.graphics.addSurface(0, terrain, "data/image/grass.jpg")
"""
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player().data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-10.0, 20.0, -20.0)).data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-15.0, 20.0, -20.0)).data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-20.0, 20.0, -20.0)).data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-30.0, 20.0, -20.0)).data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-35.0, 20.0, -20.0)).data)
self.octree.insertNode(self.octree.root, 100.0, self.octree.root, Player(position = (-40.0, 20.0, -20.0)).data)
"""
self.graphics.loadStaticObject(0.0, 0.0, 0.0, "data/model/cave.obj", \
"data/image/img2.png")
if self.args['host'] != None:
try:
self.networkThread.addr = \
(self.args['host'], self.args['port'])
network.Connect(self.args['host'], self.args['port'])
self.networkThread.start()
except:
traceback.print_exc()
self.physics.lastTime = time.time()
pygame.mouse.set_visible(0)
pygame.event.set_grab(0)
self.clock = pygame.time.Clock()
elif purpose is "FRAME_PURPOSE":
if sys.platform == "win32":
self.input.handle_mouse()
objects = self.physics.update()
rel = self.input.yrot - self.player.rotated
self.player.rotated += rel
if not self.graphics.spectator:
self.player.data.orientation = (
self.player.data.orientation[0],
(self.player.data.orientation[1] \
- rel) % 360,
self.player.data.orientation[2]
)
self.networkThread.addNewObjects()
if time.time() - self.fpsTime >= 1.0:
self.fpsTime = time.time()
self.graphics.printFPS()
#self.physics.octree.checkCollision(self.octree.root, self.player.data.position)
#self.physics.handleCollision()
self.physics.updateObjects(objects)
#self.sound.Update_Sound(objects)
self.graphics.draw(objects)
time_passed = self.clock.tick()
time_passed_seconds = time_passed / 1000.0
distance_moved = time_passed_seconds * self.input.speed
self.distance_moved = distance_moved
# I pass the keys, it can figure out the time-triggers and position-triggers itself
self.trigger_manager.Check_Triggers(self.input.keys)
def main():
#receive to this IP + port
tx_port = 7167 #TX on this port, RX on 7178 (port+1)
rx_port = tx_port+1
self_ip = whoAmI() #This needs to be THIS device's IP on the 192.168 subnet
vehicle_id = 1
#turn network messages into tokens that get sent to the right function
interface_manager = ProcessManager.TokenInterfaceManager(rx_ip=self_ip, rx_port=tx_port)
with open('routing.json') as json_file:
data = json.load(json_file)
print ( data['routing']['CAV1'] )
interface_manager.add_route('CAV1', data['routing']['CAV1']+':'+str(rx_port)) # use the RX port
interface_manager.add_route('CAV2', data['routing']['CAV2']+':'+str(rx_port)) # use the RX port
interface_manager.add_route('CAM', data['routing']['CAM']+':'+str(rx_port)) # use the RX port
interface_manager.add_route('RSU', data['routing']['RSU']+':'+str(rx_port)) # use the RX port
r_queue = multiprocessing.Queue()
#receive network interface
rx_network = Network.TTNetwork(ip=self_ip, port=rx_port, msg_receiver=interface_manager.receiver_function)
#wrapped function that needs to be synchronized
local_fusion_fp = Fusion(interface_manager.send_token_queue, vehicle_id, r_queue)
fusion_sync = WaitingMatching.InputSynchronizedFunction(Fusion.local_fusion, local_fusion_fp.input_queue)
#wrapped function that needs to be synchronized
actuation_fp = Actuation(interface_manager.send_token_queue, vehicle_id, r_queue)
actuation_sync = WaitingMatching.InputSynchronizedFunction(Actuation.actuate, actuation_fp.input_queue, use_deadline=True)
#register synchronization section with process/interface manager
interface_manager.add_sync_process(fusion_sync.function_name, fusion_sync)
interface_manager.add_sync_process(actuation_sync.function_name, actuation_sync)
# Init the camera
# Setup our various settings
settings = camera_recognition.Settings()
settings.darknetPath = '../darknet/'
camSpecs = camera_recognition.CameraSpecifications()
camSpecs.cameraHeight = .2
camSpecs.cameraAdjustmentAngle = 0.0
# Lidar settings
pipeFromC= "/home/jetson/Projects/slamware/fifo_queues/fifopipefromc"
pipeToC= "/home/jetson/Projects/slamware/fifo_queues/fifopipetoc"
# Set the time to start 10 seconds from now and let it rip!
start_time = time.time() + 10
interval = .125
cameraThread = multiprocessing.Process(target=sourceImagesThread, args=(settings, camSpecs, interface_manager.send_token_queue, start_time, interval))
cameraThread.start()
lidarThread = multiprocessing.Process(target=sourceLIDARThread, args=(pipeFromC, pipeToC, interface_manager.send_token_queue, start_time, interval))
lidarThread.start()
#need this to make sure the main process doesn't finish and carry everything into the abyss
fusion_sync.proc.join()
actuation_sync.proc.join()
def __init__(self, ui, model):
self.ui = ui
self.model = model
self.processmgr = ProcessManager.GetProcessManager()
self.ui.set_status(self.processmgr.get_serial_mux_version())
sys.exit("Neither Nimbus services nor Nimbus web are enabled. "+
"See the '%s' config file to adjust this setting." % CONFIG_PATH)
try:
services_wait = config.getint('nimbussetup', 'services.wait')
except ConfigParser.NoOptionError:
services_wait = 10
NIMBUS_RUN_DIR = os.path.join(NIMBUS_HOME, 'var/run/')
if not os.path.isdir(NIMBUS_RUN_DIR):
try:
os.mkdir(NIMBUS_RUN_DIR)
except:
sys.exit("Failed to create run directory: %s" % NIMBUS_RUN_DIR)
ProcessManager.init(dataDir = NIMBUS_RUN_DIR)
if services_enabled:
NIMBUS_SERVICES_EXE = os.path.join(NIMBUS_HOME, 'libexec/run-services.sh')
if not os.path.exists(NIMBUS_SERVICES_EXE):
sys.exit("The services executable does not exist: " +
NIMBUS_SERVICES_EXE)
ProcessManager.add( Process(
name = "services",
desc = "Nimbus services",
program = NIMBUS_SERVICES_EXE,
args = [],
workingDir = NIMBUS_HOME,
postStartDelay=services_wait
))
sys.exit("Broker is not enabled. " +
"See the '%s' config file to adjust this setting." % CONFIG_PATH)
try:
services_wait = config.getint('nimbussetup', 'services.wait')
except ConfigParser.NoOptionError:
services_wait = 10
NIMBUS_RUN_DIR = os.path.join(NIMBUS_HOME, 'var/run/')
if not os.path.isdir(NIMBUS_RUN_DIR):
try:
os.mkdir(NIMBUS_RUN_DIR)
except:
sys.exit("Failed to create run directory: %s" % NIMBUS_RUN_DIR)
ProcessManager.init(dataDir=NIMBUS_RUN_DIR)
if broker_enabled:
NIMBUS_BROKER_EXE = os.path.join(NIMBUS_HOME, 'lib/run-broker.sh')
if not os.path.exists(NIMBUS_BROKER_EXE):
sys.exit("The broker executable does not exist: " + NIMBUS_BROKER_EXE)
ProcessManager.add(
Process(name="broker",
desc="Nimbus Context Broker",
program=NIMBUS_BROKER_EXE,
args=[],
workingDir=NIMBUS_HOME,
postStartDelay=services_wait))
argv = sys.argv
if len(argv) == 2:
sys.exit("Broker is not enabled. "+
"See the '%s' config file to adjust this setting." % CONFIG_PATH)
try:
services_wait = config.getint('nimbussetup', 'services.wait')
except ConfigParser.NoOptionError:
services_wait = 10
NIMBUS_RUN_DIR = os.path.join(NIMBUS_HOME, 'var/run/')
if not os.path.isdir(NIMBUS_RUN_DIR):
try:
os.mkdir(NIMBUS_RUN_DIR)
except:
sys.exit("Failed to create run directory: %s" % NIMBUS_RUN_DIR)
ProcessManager.init(dataDir = NIMBUS_RUN_DIR)
if broker_enabled:
NIMBUS_BROKER_EXE = os.path.join(NIMBUS_HOME, 'lib/run-broker.sh')
if not os.path.exists(NIMBUS_BROKER_EXE):
sys.exit("The broker executable does not exist: " +
NIMBUS_BROKER_EXE)
ProcessManager.add( Process(
name = "broker",
desc = "Nimbus Context Broker",
program = NIMBUS_BROKER_EXE,
args = [],
workingDir = NIMBUS_HOME,
postStartDelay=services_wait
))
def __init__(self):
threading.Thread.__init__(self)
self.processManager = ProcessManager()
self.path = None
import ProcessManager
if __name__ == '__main__':
processmanager = ProcessManager.Process_Controller()
