def LoadRaycastingPreset(self, pubsub_evt=None):
if pubsub_evt:
label = pubsub_evt.data
else:
return
if label != const.RAYCASTING_OFF_LABEL:
if label in const.RAYCASTING_FILES.keys():
path = os.path.join(const.RAYCASTING_PRESETS_DIRECTORY,
const.RAYCASTING_FILES[label])
else:
path = os.path.join(const.RAYCASTING_PRESETS_DIRECTORY,
label + ".plist")
if not os.path.isfile(path):
path = os.path.join(
const.USER_RAYCASTING_PRESETS_DIRECTORY,
label + ".plist")
preset = plistlib.readPlist(path)
prj.Project().raycasting_preset = preset
# Notify volume
# TODO: Chamar grafico tb!
Publisher.sendMessage('Update raycasting preset')
else:
prj.Project().raycasting_preset = 0
Publisher.sendMessage('Update raycasting preset')
def test_03_projects_init(self):
proj_diary = project.Project(name='Diary',
fldr=root_folder,
desc='Diary database for PIM application')
proj_diary.add_source('Calendar', root_folder)
proj_diary.add_source('Bookmarks', root_folder)
proj_diary.add_source('File Usage', root_folder)
proj_diary.add_source('PC Usage', root_folder)
proj_diary.add_source('TODO List', root_folder)
proj_diary.log_table('Tasks.log')
self.assertEqual(len(str(proj_diary)) > 5, True)
my_biz = project.Project(name='Acute Software',
desc='Custom Software development',
fldr='')
my_biz.add_detail('website', 'http://www.acutesoftware.com.au')
my_biz.add_detail('email', '*****@*****.**')
self.assertEqual(len(str(my_biz)) > 5, True)
all_projects = project.Projects()
all_projects.add_project(proj_diary)
all_projects.add_project(my_biz)
all_projects.add_ontology('mapping')
res = all_projects.get_by_name('Diary')
self.assertEqual(res.desc, 'Diary database for PIM application')
self.assertEqual(len(all_projects.project_list), 2)
self.assertEqual(len(str(all_projects)), 134)
self.assertEqual(all_projects.get_by_name('No such project'), None)
def SaveProject(self, path=None):
Publisher.sendMessage('Begin busy cursor')
session = ses.Session()
if path:
dirpath, filename = os.path.split(path)
session.SaveProject((dirpath, filename))
else:
dirpath, filename = session.project_path
proj = prj.Project()
prj.Project().SavePlistProject(dirpath, filename)
session.SaveProject()
Publisher.sendMessage('End busy cursor')
def projects():
if session.get("login") is None:
return redirect("/login")
project_helper = project.Project()
all_project = {}
all_project = project_helper.get_user_project(session['id'])
return render_template("projects.html", projects=all_project)
def main():
# define the project
prj_random = prj.Project(name='Random Information Request', desc=desc, fldr=proj_fldr)
# add sources of data
prj_random.add_source('Root Ontology', os.path.abspath(os.path.join(src_fldr, 'data','ref', 'ontology.yaml')))
#prj_random.add_source('Toolboxes', os.path.abspath(os.path.join(src_fldr, 'data','ref', 'toolbox.csv')))
# parse the request for possible toolboxes to use based on local ontology
keywords = []
for s in prj_random.data_sources:
with open(s[1], 'r') as f:
for line in f:
print(s[1], ' = ' , line)
for word in line.split(' '):
keywords.append(word.strip('\n').strip(' '))
# a. split request into words
# b. lookup local ontology of words to concepts
# c. lookup toolboxes that match the concepts
print(list(set(keywords)))
# test the matching toolboxes on the source data
# a. run the test on each toolboxes
# b. compare test results and attempt to rank results
all_projects = prj.Projects()
all_projects.add_ontology('researcher')
all_projects.add_project(prj_random)
print(prj_random)
def getProjects(self):
"""
Gets the projects associated with this account (Projects need to be loaded)
"""
payload = {'email': self.email}
headers = {'APIKey': self.APIKey}
r = requests.get(config.URL + "multipleprojects.json",
params=payload,
headers=headers)
emptyProjects = []
outputString = ""
count = 0
if (r.status_code == requests.codes.ok):
data = r.text
if (data != config.INVALID_API_KEY):
jsonList = json.loads(data)
for x in jsonList:
proj = project.Project(x['name'].encode('ascii'),
self,
empty=1)
proj.id = int(x['id'])
emptyProjects.append(proj)
outputString += "(" + repr(count) + ") " + x['name'] + " "
count = count + 1
else:
raise ValueError("'" + self.APIKey + "'" +
" is not a valid API key.")
print outputString
return emptyProjects
def __init__(self):
maker.Make.__init__(self)
self.project = project.Project(
'http://petsc.cs.iit.edu/petsc/BuildSystem', self.getRoot())
self.project.setWebDirectory(
'[email protected]://mcs/www-unix/ase')
return
def main():
"""
test for rawdata module to create test files
"""
print('Initialising rawdata for AIKIF...')
# setup project for logging
name = 'rawdata_gen'
type = 'Data'
desc = 'Creates raw data tables for aikif'
desc += '\n Last updated ' + mod_dt.TodayAsString()
fldr = os.getcwd()
p = mod_prj.Project(name, type, desc, fldr)
p.add_detail('source', 'pip install rawdata')
# create the rawdata
col_names = ['Year', 'name', 'Purchase', 'Location']
col_types = ['DATE', 'PEOPLE', 'CURRENCY', 'PLACE']
t = generate.TableGenerator(10, col_types, col_names)
# save the table (you can save it via rawdata class, but demonstrates other use
test_data = mod_dt.DataTable('random.csv', ',', col_names=col_names)
p.log_table(test_data)
for row in t.tbl:
#print(row)
p.record(test_data, '', row)
p.build_report('test_raw_data.html', 'html')
p.build_report('test_raw_data.rst', 'rst')
p.build_report('test_raw_data.md', 'md')
print(test_data)
def _duplicateProject(self, proj, n=itertools.count(1)):
""" Creates a copy of a proj, and creates an accompanying spec file with an
auto-incremented counter in the name. (Not overwriting is mostly for debugging.)"""
# reload from file instead of deepcopy because hsub stuff can include uncopyable thread locks, etc
new_proj = project.Project()
new_proj.setSilent(True)
new_proj.loadProject(self.proj.getFilenamePrefix() + ".spec")
# copy hsub references manually
new_proj.hsub = proj.hsub
new_proj.hsub.proj = new_proj # oh my god, guys
new_proj.h_instance = proj.h_instance
new_proj.sensor_handler = proj.sensor_handler
new_proj.actuator_handler = proj.actuator_handler
# Choose a name by incrementing the stepX suffix
# Note: old files from previous executions will be overwritten
base_name = self.proj.getFilenamePrefix().rsplit(
'.', 1)[0] # without the modifier
newSpecName = "%s.step%d.spec" % (base_name, n.next())
new_proj.writeSpecFile(newSpecName)
logging.info("Wrote new spec file: %s" % newSpecName)
return new_proj
def loadRobotClient(specpath, otherRobotName):
"""
specpath: path to specification
"""
executor = None
proj = project.Project()
proj.loadProject(specpath)
hsub = handlerSubsystem.HandlerSubsystem(executor, proj.project_root)
hsub.setExecutingConfig(proj.current_config)
proj.rfi = proj.loadRegionFile(decomposed=True)
robClient = negotiationMonitor.robotClient.RobotClient(hsub, proj)
# loadStrategy
region_domain = [
strategy.Domain("region", proj.rfi.regions, strategy.Domain.B0_IS_MSB)
]
regionCompleted_domain = [
strategy.Domain("regionCompleted", proj.rfi.regions,
strategy.Domain.B0_IS_MSB)
]
enabled_sensors = [
x for x in proj.enabled_sensors
if not x.endswith('_rc') or x.startswith(otherRobotName)
]
strat = strategy.createStrategyFromFile(
specpath.replace('.spec', '.aut'),
enabled_sensors + regionCompleted_domain, proj.enabled_actuators +
proj.all_customs + proj.internal_props + region_domain)
return robClient, strat
def OnInsertAngularMeasurePoint(self, obj, evt):
x,y = self.interactor.GetEventPosition()
self.measure_picker.Pick(x, y, 0, self.ren)
x, y, z = self.measure_picker.GetPickPosition()
proj = prj.Project()
radius = min(proj.spacing) * PROP_MEASURE
if self.measure_picker.GetActor():
# if not self.measures or self.measures[-1].IsComplete():
# m = measures.AngularMeasure(self.ren)
# m.AddPoint(x, y, z)
# self.measures.append(m)
# else:
# m = self.measures[-1]
# m.AddPoint(x, y, z)
# if m.IsComplete():
# index = len(self.measures) - 1
# name = "M"
# colour = m.colour
# type_ = _("Angular")
# location = u"3D"
# value = u"%.2f˚"% m.GetValue()
# msg = 'Update measurement info in GUI',
# Publisher.sendMessage(msg,
# (index, name, colour,
# type_, location,
# value))
Publisher.sendMessage("Add measurement point",
((x, y,z), const.ANGULAR, const.SURFACE, radius))
self.interactor.Render()
def OnExportSurface(self, pubsub_evt):
filename, filetype = pubsub_evt.data
if (filetype == const.FILETYPE_STL) or\
(filetype == const.FILETYPE_VTP) or\
(filetype == const.FILETYPE_PLY) or\
(filetype == const.FILETYPE_STL_ASCII):
# First we identify all surfaces that are selected
# (if any)
proj = prj.Project()
polydata_list = []
for index in proj.surface_dict:
surface = proj.surface_dict[index]
if surface.is_shown:
polydata_list.append(surface.polydata)
if len(polydata_list) == 0:
utl.debug("oops - no polydata")
return
elif len(polydata_list) == 1:
polydata = polydata_list[0]
else:
polydata = pu.Merge(polydata_list)
# Having a polydata that represents all surfaces
# selected, we write it, according to filetype
if filetype == const.FILETYPE_STL:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToBinary()
elif filetype == const.FILETYPE_STL_ASCII:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToASCII()
elif filetype == const.FILETYPE_VTP:
writer = vtk.vtkXMLPolyDataWriter()
#elif filetype == const.FILETYPE_IV:
# writer = vtk.vtkIVWriter()
elif filetype == const.FILETYPE_PLY:
writer = vtk.vtkPLYWriter()
writer.SetFileTypeToASCII()
writer.SetColorModeToOff()
#writer.SetDataByteOrderToLittleEndian()
#writer.SetColorModeToUniformCellColor()
#writer.SetColor(255, 0, 0)
if filetype in (const.FILETYPE_STL, const.FILETYPE_PLY):
# Invert normals
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.UpdateInformation()
normals.Update()
polydata = normals.GetOutput()
filename = filename.encode(wx.GetDefaultPyEncoding())
writer.SetFileName(filename)
writer.SetInputData(polydata)
writer.Write()
def main(project_name):
warnings.simplefilter("error", OptimizeWarning)
proj = project.Project(project_name)
proj.prepare_quantify()
datafiles.create_file(proj)
quantify(proj)
return 0
def loadSpecFile(self, filename):
# Update with this new project
self.proj = project.Project()
self.proj.loadProject(filename)
# Tell GUI to load the spec file
self.postEvent("SPEC", self.proj.getFilenamePrefix() + ".spec")
def file_metadata():
p = prj.Project('File Metadata',
tpe='PIM',
fldr='T:\\user\\AIKIF\\pers_data\\file_metadata',
desc='Read metadata')
return p
def initDPatching(specpath):
"""
specpath: path to specification
"""
executor = None
proj = project.Project()
proj.loadProject(specpath)
hsub = handlerSubsystem.HandlerSubsystem(executor, proj.project_root)
hsub.setExecutingConfig(proj.current_config)
proj.rfi = proj.loadRegionFile(decomposed=True)
patchExecutor = centralCoordinator.decentralizedPatchingExecutor.PatchingExecutor(
hsub, proj, testDPatchingMode=True)
# loadStrategy
region_domain = [
strategy.Domain("region", proj.rfi.regions, strategy.Domain.B0_IS_MSB)
]
regionCompleted_domain = [
strategy.Domain("regionCompleted", proj.rfi.regions,
strategy.Domain.B0_IS_MSB)
]
enabled_sensors = [
x for x in proj.enabled_sensors if not x.endswith('_rc')
]
strat = strategy.createStrategyFromFile(
specpath.replace('.spec', '.aut'),
enabled_sensors + regionCompleted_domain, proj.enabled_actuators +
proj.all_customs + proj.internal_props + region_domain)
return patchExecutor, strat
def gmail():
p = prj.Project('Gmail',
tpe='PIM',
fldr='T:\\user\\AIKIF\\pers_data\\email\\gmail',
desc='Load gmail')
return p
def outlook():
p = prj.Project('Outlook',
tpe='PIM',
fldr='T:\\user\\AIKIF\\pers_data\\email',
desc='Load Outlook mail')
return p
def on_open_project(self, widget):
filechooser = gtk.FileChooserDialog(
title="Choose Project File",
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.set_name("Taluka Project Files")
filter.add_pattern("*.taluka")
filechooser.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("All Files")
filter.add_pattern("*")
filechooser.add_filter(filter)
filechooser.set_current_folder(os.environ["HOME"])
filechooser.set_transient_for(self.window)
response = filechooser.run()
if response == gtk.RESPONSE_OK:
file = filechooser.get_filename()
else:
file = None
filechooser.destroy()
if file != None:
p = project.Project(self)
p.filename = urllib.unquote(file)
p.open()
def __init__(self):
maker.Make.__init__(self)
self.project = project.Project(
'https://bitbucket.org/petsc/buildsystem', self.getRoot())
self.project.setWebDirectory(
'[email protected]://mcs/www-unix/ase')
return
def SaveRaycastingPreset(self, pubsub_evt):
preset_name = pubsub_evt.data
preset = prj.Project().raycasting_preset
preset['name'] = preset_name
preset_dir = os.path.join(const.USER_RAYCASTING_PRESETS_DIRECTORY,
preset_name + '.plist')
plistlib.writePlist(preset, preset_dir)
def OnRemove(self, pubsub_evt):
selected_items = pubsub_evt.data
proj = prj.Project()
old_dict = self.actors_dict
new_dict = {}
if selected_items:
for index in selected_items:
proj.RemoveSurface(index)
actor = old_dict[index]
for i in old_dict:
if i < index:
new_dict[i] = old_dict[i]
if i > index:
new_dict[i - 1] = old_dict[i]
old_dict = new_dict
Publisher.sendMessage('Remove surface actor from viewer',
actor)
self.actors_dict = new_dict
if self.last_surface_index in selected_items:
if self.actors_dict:
self.last_surface_index = 0
else:
self.last_surface_index = None
def CreateDicomProject(self, dicom, matrix, matrix_filename):
name_to_const = {"AXIAL":const.AXIAL,
"CORONAL":const.CORONAL,
"SAGITTAL":const.SAGITAL}
proj = prj.Project()
proj.name = dicom.patient.name
proj.modality = dicom.acquisition.modality
proj.SetAcquisitionModality(dicom.acquisition.modality)
proj.matrix_shape = matrix.shape
proj.matrix_dtype = matrix.dtype.name
proj.matrix_filename = matrix_filename
#proj.imagedata = imagedata
proj.dicom_sample = dicom
proj.original_orientation =\
name_to_const[dicom.image.orientation_label]
proj.window = float(dicom.image.window)
proj.level = float(dicom.image.level)
proj.threshold_range = int(matrix.min()), int(matrix.max())
proj.spacing = self.Slice.spacing
######
session = ses.Session()
filename = proj.name+".inv3"
filename = filename.replace("/", "") #Fix problem case other/Skull_DICOM
dirpath = session.CreateProject(filename)
def OnLinkExportMask(self, evt=None):
project = proj.Project()
print "OnLinkEportMask"
if sys.platform == 'win32':
project_name = project.name
else:
project_name = project.name + ".vti"
dlg = wx.FileDialog(
None,
"Save mask as...", # title
"", # last used directory
project_name, # filename
WILDCARD_SAVE_MASK,
wx.SAVE | wx.OVERWRITE_PROMPT)
dlg.SetFilterIndex(0) # default is VTI
if dlg.ShowModal() == wx.ID_OK:
filename = dlg.GetPath()
print "filename", filename
extension = "vti"
if sys.platform != 'win32':
if filename.split(".")[-1] != extension:
filename = filename + "." + extension
filetype = const.FILETYPE_IMAGEDATA
Publisher.sendMessage('Export mask to file', (filename, filetype))
def __init__(self):
"""
Create a new execution context object
"""
super(LTLMoPExecutor, self).__init__()
self.proj = project.Project(
) # this is the project that we are currently using to execute
self.strategy = None
# Choose a timer func with maximum accuracy for given platform
if sys.platform in ['win32', 'cygwin']:
self.timer_func = time.clock
else:
self.timer_func = time.time
self.externalEventTarget = None
self.externalEventTargetRegistered = threading.Event()
self.postEventLock = threading.Lock()
self.runStrategy = threading.Event() # Start out paused
self.alive = threading.Event()
self.alive.set()
self.current_outputs = {
} # keep track on current outputs values (for actuations)
def TestLoadAndDump(spec_filename):
import project
import pprint
import strategy # When running from the context of __name__ == "__main__", we need to
# explicitly import like this or else things get weird... e.g. __main__.Domain
# and strategy.Domain become different things
### Load the project
proj = project.Project()
proj.loadProject(spec_filename)
spec_map = proj.loadRegionFile(decomposed=True)
### Load the strategy
region_domain = strategy.Domain("region", spec_map.regions, Domain.B0_IS_MSB)
strat = createStrategyFromFile(proj.getStrategyFilename(),
proj.enabled_sensors,
proj.enabled_actuators + proj.all_customs + proj.internal_props + [region_domain])
### Choose a starting state
initial_region = spec_map.regions[0] # Hopefully this is a valid region to start from...
start_state = strat.searchForOneState({"region": initial_region, "radio": False})
#pprint.pprint(strat.findTransitionableStates({}, from_state=start_state))
### Dump the strategy from this initial state
strat.exportAsDotFile("strategy_test.dot", starting_states = [start_state])
def create_project_from_dict(self, project_dict):
return project.Project(
project_dict["name"],
project_dict["city"],
project_dict["description"],
project_dict["start_time"],
project_dict["end_time"],
)
def CloseProject(self):
proj = prj.Project()
proj.Close()
Publisher.sendMessage('Hide content panel')
Publisher.sendMessage('Close project data')
session = ses.Session()
session.CloseProject()
def run(self, worker=None, client=None):
run = LDARun(self.project, client)
loader = LDALoader.create_loader_for_inference(run)
loader.compute_lda_inference()
summaries = loader.update_summaries_in_database()
project.Project(self.project, client).update_timestamps([
project.Project.TOPIC_SCORES_TIMESTAMP])
return loader, summaries
def test_setvalues(self):
"""Test setting/getting values works"""
for testvalue, expected in self.knownvalues:
# Use fresh project instance each time
p = project.Project()
# If setting works then the value output should equal the value input
if p.dat_lump(testvalue) == True:
self.assertEqual(testvalue, p.dat_lump())
