def _validateCases(case_generator, case_count, num_workers):
global scriptlogger
scriptlogger.info('Validating input for %i cases', case_count)
errored_cases = 0
for case_idx, case, param, setting_overrides in case_generator:
if case_idx == 1 and param is not None:
if not os.path.isfile(param):
scriptlogger.error(
'Path for specified parameter file does not exist!')
else:
schemaFile, schemaFuncs = radiomics.getParameterValidationFiles(
)
c = pykwalify.core.Core(source_file=param,
schema_files=[schemaFile],
extensions=[schemaFuncs])
try:
c.validate()
except (KeyboardInterrupt, SystemExit):
raise
except Exception as e:
scriptlogger.error('Parameter validation failed!\n%s' %
e.message)
scriptlogger.debug("Validating case (%i/%i): %s", case_idx, case_count,
case)
case_error = False
if not os.path.isfile(case['Image']):
case_error = True
scriptlogger.error('Image path for case (%i/%i) does not exist!',
case_idx, case_count)
def _parseOverrides(overrides):
global scriptlogger
setting_overrides = {}
# parse overrides
if len(overrides) == 0:
scriptlogger.debug('No overrides found')
return setting_overrides
scriptlogger.debug('Reading parameter schema')
schemaFile, schemaFuncs = radiomics.getParameterValidationFiles()
with open(schemaFile) as schema:
settingsSchema = yaml.load(schema)['mapping']['setting']['mapping']
# parse single value function
def parse_value(value, value_type):
if value_type == 'str':
return value # no conversion
elif value_type == 'int':
return int(value)
elif value_type == 'float':
return float(value)
elif value_type == 'bool':
return value == '1' or value.lower() == 'true'
else:
raise ValueError('Cannot understand value_type %s' % value_type)
for setting in overrides: # setting = "setting_key:setting_value"
if ':' not in setting:
scriptlogger.warning('Incorrect format for override setting "%s", missing ":"', setting)
# split into key and value
setting_key, setting_value = setting.split(':', 2)
# Check if it is a valid PyRadiomics Setting
if setting_key not in settingsSchema:
scriptlogger.warning('Did not recognize override %s, skipping...', setting_key)
continue
# Try to parse the value by looking up its type in the settingsSchema
try:
setting_def = settingsSchema[setting_key]
setting_type = 'str' # If type is omitted in the schema, treat it as string (no conversion)
if 'seq' in setting_def:
# Multivalued setting
if len(setting_def['seq']) > 0 and 'type' in setting_def['seq'][0]:
setting_type = setting_def['seq'][0]['type']
setting_overrides[setting_key] = [parse_value(val, setting_type) for val in setting_value.split(',')]
scriptlogger.debug('Parsed "%s" as list (element type "%s"); value: %s',
setting_key, setting_type, setting_overrides[setting_key])
else:
if 'type' in setting_def:
setting_type = setting_def['type']
setting_overrides[setting_key] = parse_value(setting_value, setting_type)
scriptlogger.debug('Parsed "%s" as type "%s"; value: %s', setting_key, setting_type, setting_overrides[setting_key])
except Exception:
scriptlogger.warning('Could not parse value %s for setting %s, skipping...', setting_value, setting_key)
return setting_overrides
def main(paramsFile):
schemaFile, schemaFuncs = getParameterValidationFiles()
c = pykwalify.core.Core(source_file=paramsFile, schema_files=[schemaFile], extensions=[schemaFuncs])
try:
params = c.validate()
print('Parameter validation successfull!\n\n'
'###Enabled Features###\n%s\n'
'###Enabled Image Types###\n%s\n'
'###Settings###\n%s' % (params['featureClass'], params['imageType'], params['setting']))
except Exception as e:
print('Parameter validation failed!\n%s' % e.message)
def _applyParams(self, paramsFile=None, paramsDict=None):
"""
Validates and applies a parameter dictionary. See :py:func:`loadParams` and :py:func:`loadJSONParams` for more info.
"""
global logger
# Ensure pykwalify.core has a log handler (needed when parameter validation fails)
if len(pykwalify.core.log.handlers) == 0 and len(
logging.getLogger().handlers) == 0:
# No handler available for either pykwalify or root logger, provide first radiomics handler (outputs to stderr)
pykwalify.core.log.addHandler(
logging.getLogger('radiomics').handlers[0])
schemaFile, schemaFuncs = getParameterValidationFiles()
c = pykwalify.core.Core(source_file=paramsFile,
source_data=paramsDict,
schema_files=[schemaFile],
extensions=[schemaFuncs])
params = c.validate()
logger.debug('Parameters parsed, input is valid.')
enabledImageTypes = params.get('imageType', {})
enabledFeatures = params.get('featureClass', {})
settings = params.get('setting', {})
voxelSettings = params.get('voxelSetting', {})
logger.debug("Applying settings")
if len(enabledImageTypes) == 0:
self.enabledImagetypes = {'Original': {}}
else:
self.enabledImagetypes = enabledImageTypes
logger.debug("Enabled image types: %s", self.enabledImagetypes)
if len(enabledFeatures) == 0:
self.enabledFeatures = {}
for featureClassName in self.featureClassNames:
self.enabledFeatures[featureClassName] = []
else:
self.enabledFeatures = enabledFeatures
logger.debug("Enabled features: %s", self.enabledFeatures)
# Set default settings and update with and changed settings contained in kwargs
self.settings = self._getDefaultSettings()
self.settings.update(settings)
self.settings.update(voxelSettings)
logger.debug("Settings: %s", settings)
def loadParams(self, paramsFile):
"""
Parse specified parameters file and use it to update settings, enabled feature(Classes) and image types. For more
information on the structure of the parameter file, see
:ref:`Customizing the extraction <radiomics-customization-label>`.
If supplied file does not match the requirements (i.e. unrecognized names or invalid values for a setting), a
pykwalify error is raised.
"""
# Ensure pykwalify.core has a log handler (needed when parameter validation fails)
if len(pykwalify.core.log.handlers) == 0 and len(
logging.getLogger().handlers) == 0:
# No handler available for either pykwalify or root logger, provide first radiomics handler (outputs to stderr)
pykwalify.core.log.addHandler(
logging.getLogger('radiomics').handlers[0])
schemaFile, schemaFuncs = getParameterValidationFiles()
c = pykwalify.core.Core(source_file=paramsFile,
schema_files=[schemaFile],
extensions=[schemaFuncs])
params = c.validate()
enabledImageTypes = params.get('imageType', {})
enabledFeatures = params.get('featureClass', {})
settings = params.get('setting', {})
self.logger.debug("Parameter file parsed. Applying settings")
if len(enabledImageTypes) == 0:
self._enabledImagetypes = {'Original': {}}
else:
self._enabledImagetypes = enabledImageTypes
self.logger.debug("Enabled image types: %s", self._enabledImagetypes)
if len(enabledFeatures) == 0:
self._enabledFeatures = {}
for featureClassName in self.getFeatureClassNames():
self._enabledFeatures[featureClassName] = []
else:
self._enabledFeatures = enabledFeatures
self.logger.debug("Enabled features: %s", self._enabledFeatures)
# Set default settings and update with and changed settings contained in kwargs
self.settings = self._getDefaultSettings()
self.settings.update(settings)
self.logger.debug("Settings: %s", settings)
def __init__(self):
self.schemaFile, self.schemaFuncs = getParameterValidationFiles()
