docstr: Make sure that the user has selected some limits when filtering
docstr_tok: ["Make","sure","that","the","user","has","selected","some","limits","when","filtering"]
code: def validate_module(self, pipeline):
      """Make sure that the user has selected some limits when filtering"""
      if (
          self.mode == MODE_MEASUREMENTS
          and self.filter_choice == FI_LIMITS
      ):
          for group in self.measurements:
              if not (
                  group.wants_minimum.value or group.wants_maximum.value
              ):
                  raise ValidationError(
                      "Please enter a minimum and/or maximum limit for your measurement",
                      group.wants_minimum,
                  )
      if self.mode == MODE_RULES:
          try:
              rules = self.get_rules()
          except Exception as instance:
              LOGGER.warning(
                  "Failed to load rules: %s",
                  str(instance),
                  exc_info=True,
              )
              raise ValidationError(str(instance), self.rules_file_name)
          for r in rules.rules:
              if (
                  self.rules.Rule.return_fuzzy_measurement_name(
                      pipeline.get_measurement_columns(self),
                      r.object_name,
                      r.feature,
                      True,
                      self.allow_fuzzy,
                  )
                  == ""
              ):
                  raise ValidationError(
                      (
                          "The rules file, %s, uses the measurement, %s "
                          "for object %s, but that measurement is not available "
                          "at this stage of the pipeline. Consider editing the "
                          "rules to match the available measurements or adding "
                          "measurement modules to produce the measurement."
                      )
                      % (
                          self.rules_file_name,
                          r.feature,
                          r.object_name,
                      ),
                      self.rules_file_name,
                  )
      elif self.mode == MODE_CLASSIFIERS:
          try:
              self.get_classifier()
              self.get_bin_labels()
              self.get_classifier_features()
          except IOError:
              raise ValidationError(
                  "Failed to load classifier file %s"
                  % self.rules_file_name.value,
                  self.rules_file_name,
              )
          except:
              raise ValidationError(
                  "Unable to load %s as a classifier file"
                  % self.rules_file_name.value,
                  self.rules_file_name,
              )
          features = self.get_classifier_features()
  
          for feature in features:
              fuzzy_feature = (
                  self.rules.Rule.return_fuzzy_measurement_name(
                      pipeline.get_measurement_columns(),
                      feature[: feature.index("_")],
                      feature[feature.index("_") :],
                      True,
                      self.allow_fuzzy,
                  )
              )
              if fuzzy_feature == "":
                  raise ValidationError(
                      f"""The classifier {self.rules_file_name}, requires the measurement "{feature}", but that 
  measurement is not available at this stage of the pipeline. Consider adding modules to produce the measurement.""",
                      self.rules_file_name,
                  )
  
imports: from cellprofiler_core.constants.measurement import M_LOCATION_CENTER_X, M_LOCATION_CENTER_Y, C_CHILDREN, C_PARENT, C_LOCATION, C_NUMBER, FTR_OBJECT_NUMBER, C_COUNT, FTR_CENTER_X, FTR_CENTER_Y, FTR_CENTER_Z
  from cellprofiler_core.module.image_segmentation import ObjectProcessing
  from cellprofiler_core.preferences import DEFAULT_INPUT_FOLDER_NAME, ABSOLUTE_FOLDER_NAME, DEFAULT_INPUT_SUBFOLDER_NAME, DEFAULT_OUTPUT_SUBFOLDER_NAME
  from cellprofiler_core.setting import Divider, HiddenCount, SettingsGroup, Measurement, Binary, ValidationError
  from cellprofiler_core.setting.choice import Choice
  from cellprofiler_core.setting.do_something import DoSomething, RemoveSettingButton
  from cellprofiler_core.setting.subscriber import LabelSubscriber
  from cellprofiler_core.setting.text import Directory, Filename, Float, LabelName
  from cellprofiler.modules import _help
  import logging
  import os
  import numpy
  import scipy
  import scipy.ndimage
  import scipy.sparse
  import cellprofiler.gui.help
  import cellprofiler_core.object
  from cellprofiler.utilities.rules import Rules
label_desc: Use image node_id 11 for calling the FilterObjects obj's underlying member method code with example usage: obj.validate_module(pipeline) without return types