def getOperationsWithinGroup(self, name, fake=False, warning=True):
"""
Return a list of operations. If a grouped operation, return the operations in the group.
:param name:
:param fake:
:param warning:
:return:
@rtype: Operation
"""
op = getOperation(name, fake=False, warning=False)
if op is None:
grp = self.getGroup(name)
if grp is not None:
results = []
for filter in grp.filters:
newop = self.getOperationsWithinGroup(filter,
fake=fake,
warning=warning)
results.extend(newop)
return results
if op is None:
if fake:
return [getOperation(name, fake=True, warning=warning)]
else:
return []
return [op]
def getOperations(self, startType, endType):
cat = dict()
cat['Groups'] = list()
newset = maskgenloader.get_key(self.getLoaderKey())
if newset is None:
return cat
deleteKeys = []
for group, content in newset.iteritems():
if len(content) > 0:
first_op = getOperation(content[0])
if first_op is None:
deleteKeys.append(group)
continue
for first_op_trans in first_op.transitions:
start = first_op_trans.split('.')[0]
if start != startType:
continue
second_op = getOperation(content[-1])
if second_op is None:
deleteKeys.append(group)
continue
for second_op_trans in second_op.transitions:
end = second_op_trans.split('.')[1]
if end == endType:
cat['Groups'].append(group)
continue
for group in deleteKeys:
newset.pop(group)
return cat
def setOperationName(self,name):
self.operationName = name
if name is None:
return
op = getOperation(self.operationName)
self.category = op.category if op is not None else None
self.recordMaskInComposite='yes' if op is not None and op.includeInMask else 'no'
def getAvailableFilters(self, operations_used=list()):
has_generate_mask = set()
groups_used = set([
getOperation(op_name, fake=True).category
for op_name in operations_used
])
for op_name in operations_used:
real_op = getOperation(op_name, fake=True)
has_generate_mask.add(real_op.generateMask)
ops = getOperations()
if len(operations_used) > 1:
return []
return [op_name for op_name in ops if op_name not in operations_used and (not \
("all" in has_generate_mask and ops[op_name].generateMask == "all")) \
and not \
getOperation(op_name, fake=True).category in groups_used]
def getOperationWithGroups(self, name, fake=False, warning=True):
"""
Search groups for operation name, as the name may be a group operation
:param name:
:param fake:
:param warning:
:return:
@rtype: Operation
"""
op = getOperation(name, fake=False, warning=False)
if op is None:
op = self.getOperation(name)
if op is None:
if fake:
return getOperation(name, fake=True, warning=warning)
return op
def buildFilterOperation(pluginOp):
import copy
if pluginOp is None:
return None
realOp = getOperation(pluginOp['name'], fake=True)
mandatory = copy.copy(realOp.mandatoryparameters)
for k, v in (pluginOp['arguments'] if 'arguments' in pluginOp
and pluginOp['arguments'] is not None else {}).iteritems():
mandatory[k] = v
optional = {
k: v
for k, v in realOp.optionalparameters.iteritems() if k not in mandatory
}
logging.getLogger('maskgen').info('Build filter {}'.format(
pluginOp['name']))
return Operation(name=pluginOp['name'],
category=pluginOp['category'],
generateMask=realOp.generateMask,
mandatoryparameters=mandatory,
description=pluginOp['description'],
optionalparameters=optional,
rules=realOp.rules,
includeInMask=realOp.includeInMask,
transitions=pluginOp['transitions'],
parameter_dependencies=pluginOp['parameter_dependencies']
if 'parameter_dependencies' in pluginOp else None)
def isValid(self):
for filter in self.filters:
if getOperation(filter) is None:
logging.getLogger('maskgen').warning(
'Invalid operation {} in group {}'.format(
filter, self.name))
return False
return True
def getOperation(self, name):
grp = self.getGroup(name)
try:
return self._buildGroupOperation(
grp, name,
warning=False) if grp is not None else getOperation(name)
except Exception as e:
logging.getLogger('maskgen').error(
'Group Filter {} is in an inconsistent state: {} '.format(
name, str(e)))
return None
def checkMandatory(edge,op,graph,frm,to):
if op == 'Donor':
return None
opObj = getOperation(op)
if opObj is None:
return [op + ' is not a valid operation'] if op != 'Donor' else []
args = edge['arguments'] if 'arguments' in edge else []
missing = [param for param in opObj.mandatoryparameters.keys() if (param not in args or len(str(args[param]))== 0) and param != 'inputmaskname']
if 'inputmaskname' in opObj.mandatoryparameters.keys() and ('inputmaskname' not in edge or edge['inputmaskname'] is None or len(edge['inputmaskname']) == 0):
missing.append('inputmaskname')
return [('Mandatory parameter ' + m + ' is missing') for m in missing]
def _addAnalysis(self,startIm,destIm,op,analysis,mask,arguments={}):
import importlib
opData = getOperation(op)
if opData is None:
return
for analysisOp in opData.analysisOperations:
mod_name, func_name = analysisOp.rsplit('.',1)
mod = importlib.import_module(mod_name)
func = getattr(mod, func_name)
try:
func(analysis,startIm,destIm,mask=tool_set.invertMask(mask),arguments=arguments)
except:
print 'Failed analysis'
def newcommand(self,event):
op=getOperation(self.e2.get())
self.argBox.delete(0,END)
self.arginfo = []
self.mandatoryinfo = []
if op is not None:
for k,v in op.mandatoryparameters.iteritems():
self.__addToBox(k,True)
self.arginfo.append((k,v))
self.mandatoryinfo.append(k)
for k,v in op.optionalparameters.iteritems():
self.__addToBox(k,False)
self.arginfo.append((k,v))
if self.okButton is not None:
self.okButton.config(state=ACTIVE if self.__checkParams() else DISABLED)
def checkArguments(edge,op,graph,frm,to):
if op == 'Donor':
return None
opObj = getOperation(op)
args = [(k,v) for k,v in opObj.mandatoryparameters.iteritems()]
args.extend([(k,v) for k,v in opObj.optionalparameters.iteritems()])
results = []
for argName,argDef in args:
try:
argValue = getValue(edge,'arguments.' + argName)
if argValue:
validateAndConvertTypedValue(argName,argValue,opObj)
except ValueError as e:
results.append(argName + str(e))
return results
def changeParameter(self,event):
if len(self.argBox.curselection()) == 0:
return
index = int(self.argBox.curselection()[0])
value = self.argBox.get(index)
if self.e2.get() is not None:
op=getOperation(self.e2.get())
if op is not None:
argumentTuple = self.arginfo[index]
res = promptForParameter(self, self.dir,argumentTuple, self.uiProfile.filetypes, \
self.argvalues[argumentTuple[0]] if argumentTuple[0] in self.argvalues else None)
if argumentTuple[0] == 'inputmaskname' and res:
self.inputMaskName = res
if res is not None:
self.argvalues[argumentTuple[0]] = res
self.argBox.delete(index)
sep = '*: ' if argumentTuple[0] in self.mandatoryinfo else ': '
self.argBox.insert(index,argumentTuple[0] + sep + str(res))
self.okButton.config(state=ACTIVE if self.__checkParams() else DISABLED)
def changeParameter(self,event):
if len(self.argBox.curselection()) == 0:
return
index = int(self.argBox.curselection()[0])
value = self.argBox.get(index)
if self.optocall is not None:
op=self.pluginOps[self.optocall]
arginfo = op['arguments']
operation = getOperation(op['operation'][0])
if arginfo is not None:
arg = arginfo[index]
argumentTuple = (arg[0],operation.mandatoryparameters[arg[0]]) if operation is not None and arg[0] in operation.mandatoryparameters else None
argumentTuple = (arg[0],operation.optionalparameters[arg[0]]) if operation is not None and arg[0] in operation.optionalparameters else argumentTuple
argumentTuple = ('donor',{'type':'donor','description':'Donor'}) if arg[0] == 'donor' else argumentTuple
argumentTuple = ('inputmaskname', {'type':'imagefile','description':'Input Mask File'}) if arg[0] == 'inputmaskname' else argumentTuple
argumentTuple = (arg[0],{'type':'string','description': arg[2] if len(arg) > 2 else 'Not Available'}) if argumentTuple is None else argumentTuple
res = promptForParameter(self, self.dir, argumentTuple, self.parent.uiProfile.filetypes, arg[1])
if res is not None:
self.argvalues[arg[0]] = res
self.argBox.delete(index)
self.argBox.insert(index,arg[0] + ': ' + str(res))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--projects', required=True, help='Projects directory')
parser.add_argument('--plugin',
default=None,
help='Perform specified plugin operation')
parser.add_argument('--sourceDir',
default=None,
help='Directory of starting images')
parser.add_argument('--endDir',
default=None,
help='Directory of manipulated images')
parser.add_argument('--op', default=None, help='Operation Name')
parser.add_argument('--softwareName', default=None, help='Software Name')
parser.add_argument('--softwareVersion',
default=None,
help='Software Version')
parser.add_argument('--description',
default=None,
help='Description, in quotes')
parser.add_argument('--inputmaskpath',
default=None,
help='Directory of input masks')
parser.add_argument('--additional',
nargs='+',
default={},
help='additional operation arguments, e.g. rotation')
parser.add_argument('--continueWithWarning',
action='store_true',
help='Tag to ignore version warning')
parser.add_argument('--jpg',
action='store_true',
help='Create JPEG and copy metadata from base')
parser.add_argument('--projectDescription',
default=None,
help='Description to set to all projects')
parser.add_argument('--technicalSummary',
default=None,
help='Technical Summary to set to all projects')
parser.add_argument('--username',
default=None,
help='Username for projects')
parser.add_argument('--s3',
default=None,
help='S3 Bucket/Path to upload projects to')
args = parser.parse_args()
ops = loadOperations("operations.json")
soft = loadSoftware("software.csv")
# perform the specified operation
if args.plugin:
print 'Performing plugin operation ' + args.plugin + '...'
process_plugin(args.sourceDir, args.projects, args.plugin,
args.projectDescription, args.technicalSummary,
args.username)
elif args.sourceDir:
check_ops(ops, soft, args)
additionalArgs = check_additional_args(
args.additional, software_loader.getOperation(args.op))
process(args.sourceDir, args.endDir, args.projects, args.op,
args.softwareName, args.softwareVersion, args.description,
args.inputmaskpath, additionalArgs, args.projectDescription,
args.technicalSummary, args.username)
if args.jpg:
print 'Performing JPEG save & copying metadata from base...'
process_jpg(args.projects)
# bulk export to s3
if args.s3:
bulk_export.upload_projects(args.s3, args.projects)
def getOperation(self, name):
grp = self.getGroup(name)
return self._buildGroupOperation(
grp, name, filter=False) if grp is not None else getOperation(name)
def getCategoryForOperation(self, name):
op = getOperation(name, fake=False, warning=False)
if op is not None:
return op.category
return self.getCategoryForGroup(name)
def help(self):
op = getOperation(self.e2.get())
if op is not None:
tkMessageBox.showinfo(op.name, op.description if op.description is not None and len(op.description) > 0 else 'No description')
def _getOperation(self, name):
return getOperation(name, fake=True)
def _buildGroupOperation(self, grp, name, filter=True, warning=True):
if grp is not None:
if grp.operation is not None:
return grp.operation
includeInMask = dict()
includeInMask['default'] = False
rules = set()
opt_params = dict()
mandatory_params = dict()
dependencies = dict()
analysisOperations = set()
generateMask = "meta"
grp_categories = set()
customFunctions = {}
ops = []
if filter and not grp.isValid():
return None
logging.getLogger('maskgen').info(
'Building group {} filter {}'.format(grp, name))
compareparameters = {}
for op in grp.filters:
operation = self._getOperation(op)
ops.append(operation)
grp_categories.add(operation.category)
for k, v in operation.includeInMask.iteritems():
if k in includeInMask:
includeInMask[k] = includeInMask[k] | v
else:
includeInMask[k] = v
generateMask = chooseHigherRank(generateMask,
operation.generateMask)
addToSet(rules, operation.rules)
addToMap(mandatory_params, operation.mandatoryparameters)
addToMap(opt_params, operation.optionalparameters)
addToSet(analysisOperations, operation.analysisOperations)
addToMap(dependencies, operation.parameter_dependencies)
compareparameters.update(operation.compareparameters)
if operation.maskTransformFunction is not None:
mergeKeys(customFunctions, operation.maskTransformFunction)
opt_params = dict([(k, v) for (k, v) in opt_params.iteritems()
if k is not mandatory_params])
transitions = get_transitions(ops)
if len(customFunctions) > 0:
for k in customFunctions:
if len(customFunctions[k]) > 0:
#TODO...not using this now...list vs. str issue
customFunctions[k] = customFunctions[k]
else:
customFunctions[k] = customFunctions[k][0]
return Operation(name=name,
category='Groups',
includeInMask=includeInMask,
generateMask=generateMask,
mandatoryparameters=mandatory_params,
description='User Defined',
optionalparameters=opt_params,
rules=list(rules),
transitions=transitions,
groupedOperations=grp.filters,
compareparameters=compareparameters,
groupedCategories=grp_categories,
analysisOperations=analysisOperations,
maskTransformFunction=customFunctions,
parameter_dependencies=dependencies)
return grp.operation
return getOperation(name, fake=True, warning=warning)
def checkOperation(edge,op,graph,frm,to):
if op == 'Donor':
return None
opObj = getOperation(op)
if opObj is None:
return ['Operation ' + op + ' is invalid']
