def validate_module(self, pipeline): """Make sure chosen objects and images are selected only once""" settings = {} for group in self.images: if ( group.image_name.value, group.wants_objects.value, group.object_name.value, ) in settings: if not group.wants_objects.value: raise cps.ValidationError( "%s has already been selected" % group.image_name.value, group.image_name, ) else: raise cps.ValidationError( "%s has already been selected with %s" % (group.object_name.value, group.image_name.value), group.object_name, ) settings[( group.image_name.value, group.wants_objects.value, group.object_name.value, )] = True
def validate_module(self, pipeline): """Make sure chosen objects, images and scales are selected only once""" images = set() for group in self.image_groups: if group.image_name.value in images: raise cps.ValidationError( "%s has already been selected" %group.image_name.value, group.image_name) images.add(group.image_name.value) objects = set() for group in self.object_groups: if group.object_name.value in objects: raise cps.ValidationError( "%s has already been selected" %group.object_name.value, group.object_name) objects.add(group.object_name.value) scales = set() for group in self.scale_groups: if group.scale.value in scales: raise cps.ValidationError( "%s has already been selected" %group.scale.value, group.scale) scales.add(group.scale.value)
def validate_group(): bin_name_count = len(bin_feature_names()) bin_count = number_of_bins() if bin_count < 1: bad_setting = (group.bin_count if group.bin_choice == BC_EVEN else group.custom_thresholds) raise cps.ValidationError( "You must have at least one bin in order to take measurements. " "Either add more bins or ask for bins for objects above or below threshold", bad_setting, ) if bin_name_count != number_of_bins(): raise cps.ValidationError( "The number of bin names (%d) does not match the number of bins (%d)." % (bin_name_count, bin_count), group.bin_names, ) for bin_feature_name in bin_feature_names(): cps.AlphanumericText.validate_alphanumeric_text( bin_feature_name, group.bin_names, True) if group.bin_choice == BC_CUSTOM: try: [ float(x.strip()) for x in group.custom_thresholds.value.split(",") ] except ValueError: raise cps.ValidationError( "Custom thresholds must be a comma-separated list " 'of numbers (example: "1.0, 2.3, 4.5")', group.custom_thresholds, )
def validate_module(self, pipeline): '''Make sure that the user has selected at least one measurement for TrAM and that there are tracking data.''' if len(self.get_selected_tram_measurements()) == 0: raise cps.ValidationError( "Please select at least one TrAM measurement for tracking of {}".format(self.object_name.value), self.tram_measurements) # check on available tracking columns for the selected object obj_name = self.object_name.value mc = pipeline.get_measurement_columns() num_tracking_cols = len([entry for entry in mc if entry[0] == obj_name and entry[1].startswith(trackobjects.F_PREFIX)]) if num_tracking_cols == 0: msg = "No {} data available for {}. Please select an object with tracking data.".format(trackobjects.F_PREFIX, obj_name) raise cps.ValidationError(msg, self.object_name)
def validate_module(self, pipeline): """If using rules, validate them""" for flag in self.flags: for measurement_setting in flag.measurement_settings: if measurement_setting.source_choice == S_RULES: try: rules = self.get_rules(measurement_setting) except Exception as instance: logger.warning("Failed to load rules: %s", str(instance), exc_info=True) raise cps.ValidationError( str(instance), measurement_setting.rules_file_name) if not np.all( [r.object_name == cpmeas.IMAGE for r in rules.rules]): raise cps.ValidationError( "The rules listed in %s describe objects instead of images." % measurement_setting.rules_file_name.value, measurement_setting.rules_file_name, ) rule_features = [r.feature for r in rules.rules] measurement_cols = [ c[1] for c in pipeline.get_measurement_columns(self) ] undef_features = list( set(rule_features).difference(measurement_cols)) if len(undef_features) > 0: raise cps.ValidationError( "The rule described by %s has not been measured earlier in the pipeline." % undef_features[0], measurement_setting.rules_file_name, ) elif measurement_setting.source_choice == S_CLASSIFIER: try: self.get_classifier(measurement_setting) self.get_classifier_features(measurement_setting) self.get_bin_labels(measurement_setting) except IOError: raise cps.ValidationError( "Failed to load classifier file %s" % measurement_setting.rules_file_name.value, measurement_setting.rules_file_name, ) except: raise cps.ValidationError( "Unable to load %s as a classifier file" % measurement_setting.rules_file_name.value, measurement_setting.rules_file_name, )
def validate_module(self, pipeline): """Make sure that the row and column are different""" if self.auto_or_manual == AM_MANUAL and self.manual_choice == MAN_COORDINATES: if self.first_spot_row.value == self.second_spot_row.value: raise cps.ValidationError( "The first and second row numbers must be different in " "order to calculate the distance between rows.", self.second_spot_row, ) if self.first_spot_col.value == self.second_spot_col.value: raise cps.ValidationError( "The first and second column numbers must be different " "in order to calculate the distance between columns.", self.second_spot_col, )
def validate_module(self, pipeline): """Make sure the module settings are valid""" # Ensure we're not an un-updatable version of the module from way back. if self.from_old_matlab.value: raise cps.ValidationError( "The pipeline you loaded was from an old version of CellProfiler 1.0, " "which could not be made compatible with this version of CellProfiler.", self.acknowledge_old_matlab, ) # This must be the last module in the pipeline if id(self) != id(pipeline.modules()[-1]): raise cps.ValidationError( "The CreateBatchFiles module must be " "the last in the pipeline.", self.wants_default_output_directory, )
def validate_module_warnings(self, pipeline): """Warn user re: Test mode """ if pipeline.test_mode: raise cps.ValidationError( "CreateBatchFiles will not produce output in Test Mode", self.wants_default_output_directory, )
def validate_module_warnings(self, pipeline): """Warn user re: Test mode """ if pipeline.test_mode: raise cps.ValidationError( "CalculateStatistics will not produce any output in test mode", self.grouping_values, )
def validate_module(self, pipeline): if ( self.relabel_option == OPTION_MERGE and self.merge_option == UNIFY_PARENT and self.parent_object.value == "None" ): raise cps.ValidationError( "%s is not a valid object name" % "None", self.parent_object )
def validate_module(self, pipeline): """Make sure the user has at least one of the grayscale boxes checked""" if (self.input_color_choice == CC_GRAYSCALE and (not self.wants_red_input.value) and (not self.wants_green_input.value) and (not self.wants_blue_input.value)): raise cps.ValidationError( "You must supply at least one grayscale input", self.wants_red_input)
def validate_module(self, pipeline): """Make sure settings are compatible. In particular, we make sure that no measurements are duplicated""" measurements, sources = self.get_measurement_columns( pipeline, return_sources=True) d = {} for m, s in zip(measurements, sources): if m in d: raise cps.ValidationError( "Measurement %s made twice." % (m[1]), s[0]) d[m] = True
def validate_module_warnings(self, pipeline): """If a CP 1.0 pipeline used a rescaling option other than 'No rescaling', warn the user.""" for j, image in enumerate(self.images): if image.rescale_option != RE_NONE: raise cps.ValidationError( ("Your original pipeline used '%s' to rescale the final image, " "but the rescaling option has been removed. Please use " "RescaleIntensity to rescale your output image. Save your " "pipeline to get rid of this warning.") % image.rescale_option, image.divide_or_subtract, )
def validate_module(self, pipeline): """Validate a module's settings""" for setting in ( self.omero_host, self.omero_port, self.omero_username, self.omero_password, ): if setting.value == "": raise cps.ValidationError( 'Cannot continue if "%s" is not set.' % setting.get_text(), setting)
def get_rules(self, measurement_group): """Read the rules from a file""" rules_file = measurement_group.rules_file_name.value rules_directory = measurement_group.rules_directory.get_absolute_path() path = os.path.join(rules_directory, rules_file) if not os.path.isfile(path): raise cps.ValidationError("No such rules file: %s" % path, rules_file) else: rules = cprules.Rules() rules.parse(path) return rules
def validate_module(self, pipeline): """Make sure that the module's settings are consistent We need at least one image name to be filled in """ if self.scheme_choice not in (SCHEME_STACK, SCHEME_COMPOSITE): if all([ color_scheme_setting.image_name.is_blank for color_scheme_setting in self.color_scheme_settings ]): raise cps.ValidationError( "At least one of the images must not be blank", self.color_scheme_settings[0].image_name, )
def validate_module(self, pipeline): """Test to see if the module is in a valid state to run Throw a ValidationError exception with an explanation if a module is not valid. Make sure that we output at least one image if split """ if self.should_split(): if (self.rgb_or_channels == CH_RGB) and not any([ self.use_red.value, self.use_blue.value, self.use_green.value ]): raise cps.ValidationError( "You must output at least one of the color images when in split mode", self.use_red, ) if (self.rgb_or_channels == CH_HSV) and not any([ self.use_hue.value, self.use_saturation.value, self.use_value.value ]): raise cps.ValidationError( "You must output at least one of the color images when in split mode", self.use_hue, )
def load_classifier(self, measurement_group): """Load the classifier pickle if not cached returns classifier, bin_labels, name and features """ d = self.get_dictionary() file_ = measurement_group.rules_file_name.value directory_ = measurement_group.rules_directory.get_absolute_path() path_ = os.path.join(directory_, file_) if path_ not in d: if not os.path.isfile(path_): raise cps.ValidationError("No such rules file: %s" % path_, self.rules_file_name) else: from sklearn.externals import joblib d[path_] = joblib.load(path_) return d[path_]
def validate_module(self, pipeline): """Make sure the settings are consistent Check to make sure that we have enough rows and columns if we are in PlaceAdjacent mode. """ if (self.tile_method == T_WITHIN_CYCLES and (not self.wants_automatic_rows) and (not self.wants_automatic_columns) and self.rows.value * self.columns.value < len(self.additional_images) + 1): raise cps.ValidationError( "There are too many images (%d) for a %d by %d grid" % ( len(self.additional_images) + 1, self.columns.value, self.rows.value, ), self.rows, )
def validate_module(self, pipeline): """Do further validation on this module's settings pipeline - this module's pipeline Check to make sure the output measurements aren't duplicated by prior modules. """ all_object_names = [ operand.operand_objects.value for operand in self.operands if operand.object != cpmeas.IMAGE ] for module in pipeline.modules(): if module.module_num == self.module_num: break for name in all_object_names: features = module.get_measurements(pipeline, name, C_MATH) if self.output_feature_name.value in features: raise cps.ValidationError( 'The feature, "%s", was already defined in module # %d' % (self.output_feature_name.value, module.module_num), self.output_feature_name, )