docstr: Run the module. Add the measurements. 
docstr_tok: ["Run","the","module",".","Add","the","measurements","."]
code: def run(self, workspace):
      """Run the module. Add the measurements."""
  
      statistics_dict = {}
      ratio_dict = {}
      for channel in self.channels:
          provider = workspace.image_set.get_image_provider(
              channel.cpimage_name.value
          )
          assert isinstance(provider, OmeroImageProvider)
  
          name = provider.get_name()
          omero_image_name = provider.get_omero_image_name()
          omero_image_id = provider.get_image_id()
          pixels_id = provider.get_pixels_id()
          z = provider.get_z()
          c = provider.get_c()
          t = provider.get_t()
  
          header = []
          row = []
          ratio = []
          m = workspace.measurements
          measurements = ()
          if self.omero_object == MS_DATASET:
              measurements += (
                  (M_DATASET_NAME, self.dataset_name, 3.0),
                  (M_DATASET_ID, self.omero_object_id.value, 1.0),
              )
          elif self.omero_object == MS_PLATE:
              # CellProfiler starts counting image sets from 1
              well = self.wells[
                  workspace.measurements.image_set_number - 1
              ]
              well_row = well.getRow().getValue()
              well_column = well.getColumn().getValue()
              well_id = well.getId().getValue()
              measurements += (
                  (M_PLATE_NAME, self.plate_name, 3.0),
                  (M_PLATE_ID, self.omero_object_id.value, 1.0),
                  (M_WELL_ROW, well_row, 1.0),
                  (M_WELL_COLUMN, well_column, 1.0),
                  (M_WELL_ID, well_id, 3.0),
              )
          measurements += (
              (M_IMAGE_NAME, omero_image_name, 3.0),
              (M_IMAGE_ID, omero_image_id, 1.0),
              (M_PIXELS_ID, pixels_id, 1.0),
              (M_Z, z, 0.5),
              (M_C, c, 0.5),
              (M_T, t, 0.5),
          )
          for tag, value, r in measurements:
              m.add_image_measurement("_".join((tag, name)), value)
              header.append(tag)
              row.append(value)
              ratio.append(r)
          statistics = [header, row]
          ratio = [x / sum(ratio) for x in ratio]
          statistics_dict[channel.channel_number.value] = statistics
          ratio_dict[channel.channel_number.value] = ratio
  
      workspace.display_data.statistics = statistics_dict
      workspace.display_data.ratio = ratio_dict
  
      if cpp.get_headless():  # headless mode
          for channel in self.channels:
              image_name, channel_number = (
                  channel.cpimage_name.value,
                  channel.channel_number.value,
              )
              print(
                  "--- image name: %s\tchannel: %s"
                  % (image_name, channel_number)
              )
              (header, row) = workspace.display_data.statistics[
                  channel_number
              ]
              for i in range(0, len(header)):
                  print("\t%s: %s" % (header[i], row[i]))
  
imports: import traceback
  import numpy
  import wx
  import cellprofiler_core.image
  import cellprofiler_core.module
  import cellprofiler_core.measurement
  import cellprofiler_core.preferences
  import cellprofiler_core.setting
  from cellprofiler_core.modules import default_cpimage_name
  import omero
  from omero.rtypes import rlong
  from omero.rtypes import rint
  from omero_version import omero_version
label_desc: Use image node_id 17 for calling the OmeroLoadImages obj's underlying member method code with example usage: obj.run(workspace) without return types