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()