def create_settings(self): """Create the module settings and name the module""" self.wants_default_output_directory = cps.Binary( "Store batch files in default output folder?", True, doc="""\ Select "*Yes*" to store batch files in the Default Output folder. Select "*No*" to enter the path to the folder that will be used to store these files. The Default Output folder can be set by clicking the "View output settings" button in the main CP window, or in CellProfiler Preferences. """ % globals(), ) self.custom_output_directory = cps.Text( "Output folder path", cpprefs.get_default_output_directory(), doc= "Enter the path to the output folder. (Used only if not using the default output folder)", ) # Worded this way not because I am windows-centric but because it's # easier than listing every other OS in the universe except for VMS self.remote_host_is_windows = cps.Binary( "Are the cluster computers running Windows?", False, doc="""\ Select "*Yes*" if the cluster computers are running one of the Microsoft Windows operating systems. In this case, **CreateBatchFiles** will modify all paths to use the Windows file separator (backslash \\\\ ). Select "*No*" for **CreateBatchFiles** to modify all paths to use the Unix or Macintosh file separator (slash / ).""" % globals(), ) self.batch_mode = cps.Binary("Hidden: in batch mode", False) self.distributed_mode = cps.Binary("Hidden: in distributed mode", False) self.default_image_directory = cps.Setting( "Hidden: default input folder at time of save", cpprefs.get_default_image_directory(), ) self.revision = cps.Integer("Hidden: revision number", 0) self.from_old_matlab = cps.Binary("Hidden: from old matlab", False) self.acknowledge_old_matlab = cps.DoSomething( "Could not update CP1.0 pipeline to be compatible with CP2.0. See module notes.", "OK", self.clear_old_matlab, ) self.mappings = [] self.add_mapping() self.add_mapping_button = cps.DoSomething( "", "Add another path mapping", self.add_mapping, doc="""\ Use this option if another path must be mapped because there is a difference between how the local computer sees a folder location vs. how the cluster computer sees the folder location.""", )
def create_settings(self): self.omero_host = cps.Text( "Host address", DEFAULT_OMERO_HOST, doc= """Host address of an omero server. Can be an ip-address or a hostname.""", ) self.omero_port = cps.Integer("Port", DEFAULT_OMERO_PORT, doc="""Port of an omero server.""") self.omero_username = cps.Text( "Username", DEFAULT_OMERO_USERNAME, doc="""Username is required for login into an omero server.""", ) self.omero_password = cps.Text( "Password", DEFAULT_OMERO_PASSWORD, doc="""Password is required for login into an omero server.""", ) self.omero_object = cps.Choice("Object to load", [MS_IMAGE, MS_DATASET, MS_PLATE], DEFAULT_OMERO_OBJECT) self.omero_object_id = cps.Integer( "Object id", DEFAULT_OMERO_OBJECT_ID, doc= """This is a number that omero uses to uniquely identify an object, be it a dataset, plate, or image.""", ) self.load_channels = cps.DoSomething("", "Load channels from OMERO", self.load_channels) # All the omero images that are loaded are assumed to have # as many or more channels than the highest channel number # the user specifies. self.channels = [] self.channel_count = cps.HiddenCount(self.channels, "Channel count") # Add the first channel self.add_channelfn(False) # Button for adding other channels self.add_channel = cps.DoSomething("", "Add another channel", self.add_channelfn)
def create_settings(self): self.x_object = cps.ObjectNameSubscriber( "Select the object to display on the X-axis", "None", doc="""\ Choose the name of objects identified by some previous module (such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose measurements are to be displayed on the X-axis. """, ) self.x_axis = cps.Measurement( "Select the object measurement to plot on the X-axis", self.get_x_object, "None", doc= """Choose the object measurement made by a previous module to display on the X-axis.""", ) self.y_object = cps.ObjectNameSubscriber( "Select the object to display on the Y-axis", "None", doc="""\ Choose the name of objects identified by some previous module (such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose measurements are to be displayed on the Y-axis. """, ) self.y_axis = cps.Measurement( "Select the object measurement to plot on the Y-axis", self.get_y_object, "None", doc= """Choose the object measurement made by a previous module to display on the Y-axis.""", ) self.gridsize = cps.Integer( "Select the grid size", 100, 1, 1000, doc="""\ Enter the number of grid regions you want used on each axis. Increasing the number of grid regions increases the resolution of the plot.""", ) self.xscale = cps.Choice( "How should the X-axis be scaled?", ["linear", "log"], None, doc="""\ The X-axis can be scaled either with a *linear* scale or with a *log* (base 10) scaling. Using a log scaling is useful when one of the measurements being plotted covers a large range of values; a log scale can bring out features in the measurements that would not easily be seen if the measurement is plotted linearly. """, ) self.yscale = cps.Choice( "How should the Y-axis be scaled?", ["linear", "log"], None, doc="""\ The Y-axis can be scaled either with a *linear* scale or with a *log* (base 10) scaling. Using a log scaling is useful when one of the measurements being plotted covers a large range of values; a log scale can bring out features in the measurements that would not easily be seen if the measurement is plotted linearly. """, ) self.bins = cps.Choice( "How should the colorbar be scaled?", ["linear", "log"], None, doc="""\ The colorbar can be scaled either with a *linear* scale or with a *log* (base 10) scaling. Using a log scaling is useful when one of the measurements being plotted covers a large range of values; a log scale can bring out features in the measurements that would not easily be seen if the measurement is plotted linearly. """, ) maps = [ m for m in list(matplotlib.cm.datad.keys()) if not m.endswith("_r") ] maps.sort() self.colormap = cps.Choice( "Select the color map", maps, "jet", doc="""\ Select the color map for the density plot. See `this page`_ for pictures of the available colormaps. .. _this page: http://matplotlib.org/users/colormaps.html """, ) self.title = cps.Text( "Enter a title for the plot, if desired", "", doc="""\ Enter a title for the plot. If you leave this blank, the title will default to *(cycle N)* where *N* is the current image cycle being executed. """, )
def add_single_measurement(self, can_delete=True): """Add a single measurement to the group of single measurements can_delete - True to include a "remove" button, False if you're not allowed to remove it. """ group = cps.SettingsGroup() if can_delete: group.append("divider", cps.Divider(line=True)) group.append( "object_name", cps.ObjectNameSubscriber( "Select the object to be classified", "None", doc="""\ The name of the objects to be classified. You can choose from objects created by any previous module. See **IdentifyPrimaryObjects**, **IdentifySecondaryObjects**, **IdentifyTertiaryObjects**, or **Watershed** """, ), ) def object_fn(): return group.object_name.value group.append( "measurement", cps.Measurement( "Select the measurement to classify by", object_fn, doc="""\ *(Used only if using a single measurement)* Select a measurement made by a previous module. The objects will be classified according to their values for this measurement. """, ), ) group.append( "bin_choice", cps.Choice( "Select bin spacing", [BC_EVEN, BC_CUSTOM], doc="""\ *(Used only if using a single measurement)* Select how you want to define the spacing of the bins. You have the following options: - *%(BC_EVEN)s:* Choose this if you want to specify bins of equal size, bounded by upper and lower limits. If you want two bins, choose this option and then provide a single threshold when asked. - *%(BC_CUSTOM)s:* Choose this option to create the indicated number of bins at evenly spaced intervals between the low and high threshold. You also have the option to create bins for objects that fall below or above the low and high threshold. """ % globals(), ), ) group.append( "bin_count", cps.Integer( "Number of bins", 3, minval=1, doc="""\ *(Used only if using a single measurement)* This is the number of bins that will be created between the low and high threshold""", ), ) group.append( "low_threshold", cps.Float( "Lower threshold", 0, doc="""\ *(Used only if using a single measurement and "%(BC_EVEN)s" selected)* This is the threshold that separates the lowest bin from the others. The lower threshold, upper threshold, and number of bins define the thresholds of bins between the lowest and highest. """ % globals(), ), ) group.append( "wants_low_bin", cps.Binary( "Use a bin for objects below the threshold?", False, doc="""\ *(Used only if using a single measurement)* Select "*Yes*" if you want to create a bin for objects whose values fall below the low threshold. Select "*No*" if you do not want a bin for these objects. """ % globals(), ), ) def min_upper_threshold(): return group.low_threshold.value + np.finfo(float).eps group.append( "high_threshold", cps.Float( "Upper threshold", 1, minval=cps.NumberConnector(min_upper_threshold), doc="""\ *(Used only if using a single measurement and "%(BC_EVEN)s" selected)* This is the threshold that separates the last bin from the others. Note that if you would like two bins, you should select "*%(BC_CUSTOM)s*". """ % globals(), ), ) group.append( "wants_high_bin", cps.Binary( "Use a bin for objects above the threshold?", False, doc="""\ *(Used only if using a single measurement)* Select "*Yes*" if you want to create a bin for objects whose values are above the high threshold. Select "*No*" if you do not want a bin for these objects. """ % globals(), ), ) group.append( "custom_thresholds", cps.Text( "Enter the custom thresholds separating the values between bins", "0,1", doc="""\ *(Used only if using a single measurement and "%(BC_CUSTOM)s" selected)* This setting establishes the threshold values for the bins. You should enter one threshold between each bin, separating thresholds with commas (for example, *0.3, 1.5, 2.1* for four bins). The module will create one more bin than there are thresholds. """ % globals(), ), ) group.append( "wants_custom_names", cps.Binary( "Give each bin a name?", False, doc="""\ *(Used only if using a single measurement)* Select "*Yes*" to assign custom names to bins you have specified. Select "*No*" for the module to automatically assign names based on the measurements and the bin number. """ % globals(), ), ) group.append( "bin_names", cps.Text( "Enter the bin names separated by commas", "None", doc="""\ *(Used only if "Give each bin a name?" is checked)* Enter names for each of the bins, separated by commas. An example including three bins might be *First,Second,Third*.""", ), ) group.append( "wants_images", cps.Binary( "Retain an image of the classified objects?", False, doc="""\ Select "*Yes*" to keep an image of the objects which is color-coded according to their classification, for use later in the pipeline (for example, to be saved by a **SaveImages** module). """ % globals(), ), ) group.append( "image_name", cps.ImageNameProvider( "Name the output image", "ClassifiedNuclei", doc= """Enter the name to be given to the classified object image.""", ), ) group.can_delete = can_delete def number_of_bins(): """Return the # of bins in this classification""" if group.bin_choice == BC_EVEN: value = group.bin_count.value else: value = len(group.custom_thresholds.value.split(",")) - 1 if group.wants_low_bin: value += 1 if group.wants_high_bin: value += 1 return value group.number_of_bins = number_of_bins def measurement_name(): """Get the measurement name to use inside the bin name Account for conflicts with previous measurements """ measurement_name = group.measurement.value other_same = 0 for other in self.single_measurements: if id(other) == id(group): break if other.measurement.value == measurement_name: other_same += 1 if other_same > 0: measurement_name += str(other_same) return measurement_name def bin_feature_names(): """Return the feature names for each bin""" if group.wants_custom_names: return [ name.strip() for name in group.bin_names.value.split(",") ] return [ "_".join((measurement_name(), "Bin_%d" % (i + 1))) for i in range(number_of_bins()) ] group.bin_feature_names = bin_feature_names 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, ) group.validate_group = validate_group if can_delete: group.remove_settings_button = cps.RemoveSettingButton( "", "Remove this classification", self.single_measurements, group) self.single_measurements.append(group)
def create_settings(self): self.x_source = cps.Choice( "Type of measurement to plot on X-axis", SOURCE_CHOICE, doc="""\ You can plot two types of measurements: - *%(SOURCE_IM)s:* For a per-image measurement, one numerical value is recorded for each image analyzed. Per-image measurements are produced by many modules. Many have **MeasureImage** in the name but others do not (e.g., the number of objects in each image is a per-image measurement made by the **Identify** modules). - *%(SOURCE_OBJ)s:* For a per-object measurement, each identified object is measured, so there may be none or many numerical values recorded for each image analyzed. These are usually produced by modules with **MeasureObject** in the name. """ % globals(), ) self.x_object = cps.ObjectNameSubscriber( "Select the object to plot on the X-axis", "None", doc="""\ *(Used only when plotting objects)* Choose the name of objects identified by some previous module (such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose measurements are to be displayed on the X-axis. """, ) self.x_axis = cps.Measurement( "Select the measurement to plot on the X-axis", self.get_x_object, "None", doc="""Choose the measurement (made by a previous module) to plot on the X-axis.""", ) self.y_source = cps.Choice( "Type of measurement to plot on Y-axis", SOURCE_CHOICE, doc="""\ You can plot two types of measurements: - *%(SOURCE_IM)s:* For a per-image measurement, one numerical value is recorded for each image analyzed. Per-image measurements are produced by many modules. Many have **MeasureImage** in the name but others do not (e.g., the number of objects in each image is a per-image measurement made by **Identify** modules). - *%(SOURCE_OBJ)s:* For a per-object measurement, each identified object is measured, so there may be none or many numerical values recorded for each image analyzed. These are usually produced by modules with **MeasureObject** in the name. """ % globals(), ) self.y_object = cps.ObjectNameSubscriber( "Select the object to plot on the Y-axis", "None", doc="""\ *(Used only when plotting objects)* Choose the name of objects identified by some previous module (such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose measurements are to be displayed on the Y-axis. """, ) self.y_axis = cps.Measurement( "Select the measurement to plot on the Y-axis", self.get_y_object, "None", doc="""Choose the measurement (made by a previous module) to plot on the Y-axis.""", ) self.xscale = cps.Choice( "How should the X-axis be scaled?", SCALE_CHOICE, None, doc="""\ The X-axis can be scaled with either a *linear* scale or a *log* (base 10) scaling. Log scaling is useful when one of the measurements being plotted covers a large range of values; a log scale can bring out features in the measurements that would not easily be seen if the measurement is plotted linearly. """, ) self.yscale = cps.Choice( "How should the Y-axis be scaled?", SCALE_CHOICE, None, doc="""\ The Y-axis can be scaled with either a *linear* scale or with a *log* (base 10) scaling. Log scaling is useful when one of the measurements being plotted covers a large range of values; a log scale can bring out features in the measurements that would not easily be seen if the measurement is plotted linearly. """, ) self.title = cps.Text( "Enter a title for the plot, if desired", "", doc="""\ Enter a title for the plot. If you leave this blank, the title will default to *(cycle N)* where *N* is the current image cycle being executed. """, )
def add_mapping(self): group = cps.SettingsGroup() group.append( "local_directory", cps.Text( "Local root path", cpprefs.get_default_image_directory(), doc="""\ Enter the path to files on this computer. This is the root path on the local machine (i.e., the computer setting up the batch files). For instance, a Windows machine might access files images by mounting the file system using a drive letter, like this: ``Z:\your_data\images`` and the cluster computers access the same file system like this: ``/server_name/your_name/your_data/images`` In this case, since the ``your_data\images`` portion of the path is the same for both, the local root path is the portion prior, i.e., ``Z:\`` and similarly for the cluster root path, i.e., ``/server_name/your_name/``. If **CreateBatchFiles** finds any pathname that matches the local root path at the beginning, it will replace that matching portion with the cluster root path. For example, if you have mapped the remote cluster machine like this: ``Z:\your_data\images`` (on a Windows machine, for instance) and the cluster machine sees the same folder like this: ``/server_name/your_name/your_data/images`` you would enter ``Z:\`` here for the local root path and ``/server_name/your_name/`` for the cluster root path in the next setting.""", ), ) group.append( "remote_directory", cps.Text( "Cluster root path", cpprefs.get_default_image_directory(), doc="""\ Enter the path to files on the cluster. This is the cluster root path, i.e., how the cluster machine sees the top-most folder where your input/output files are stored. For instance, a Windows machine might access files images by mounting the file system using a drive letter, like this: ``Z:\your_data\images`` and the cluster computers access the same file system like this: ``/server_name/your_name/your_data/images`` In this case, since the ``your_data\images`` portion of the path is the same for both, the local root path is the portion prior, i.e., ``Z:\`` and similarly for the cluster root path, i.e., ``/server_name/your_name/``. If **CreateBatchFiles** finds any pathname that matches the local root path at the beginning, it will replace that matching portion with the cluster root path. For example, if you have mapped the remote cluster machine like this: ``Z:\your_data\images`` (on a Windows machine, for instance) and the cluster machine sees the same folder like this: ``/server_name/your_name/your_data/images`` you would enter ``Z:\`` in the previous setting for the local root path and ``/server_name/your_name/`` here for the cluster root path.""", ), ) group.append( "remover", cps.RemoveSettingButton("", "Remove this path mapping", self.mappings, group), ) group.append("divider", cps.Divider(line=False)) self.mappings.append(group)
def add_flag(self, can_delete=True): group = cps.SettingsGroup() group.append("divider1", cps.Divider(line=False)) group.append("measurement_settings", []) group.append("measurement_count", cps.HiddenCount(group.measurement_settings)) group.append( "category", cps.Text( "Name the flag's category", "Metadata", doc="""\ Name a measurement category by which to categorize the flag. The *Metadata* category is the default used in CellProfiler to store information about images (referred to as *metadata*). The flag is stored as a per-image measurement whose name is a combination of the flag’s category and the flag name that you choose, separated by underscores. For instance, if the measurement category is *Metadata* and the flag name is *QCFlag*, then the default measurement name would be *Metadata_QCFlag*. """, ), ) group.append( "feature_name", cps.Text( "Name the flag", "QCFlag", doc="""\ The flag is stored as a per-image measurement whose name is a combination of the flag’s category and the flag name that you choose, separated by underscores. For instance, if the measurement category is *Metadata* and the flag name is *QCFlag*, then the default measurement name would be *Metadata_QCFlag*. """, ), ) group.append( "combination_choice", cps.Choice( "How should measurements be linked?", [C_ANY, C_ALL], doc="""\ For combinations of measurements, you can set the criteria under which an image set is flagged: - *%(C_ANY)s:* An image set will be flagged if any of its measurements fail. This can be useful for flagging images possessing multiple QC flaws; for example, you can flag all bright images and all out of focus images with one flag. - *%(C_ALL)s:* A flag will only be assigned if all measurements fail. This can be useful for flagging images that possess only a combination of QC flaws; for example, you can flag only images that are both bright and out of focus. """ % globals(), ), ) group.append( "wants_skip", cps.Binary( "Skip image set if flagged?", False, doc="""\ Select *Yes* to skip the remainder of the pipeline for image sets that are flagged. CellProfiler will not run subsequent modules in the pipeline on the images for any image set that is flagged. Select *No* for CellProfiler to continue to process the pipeline regardless of flagging. You may want to skip processing in order to filter out unwanted images. For instance, you may want to exclude out of focus images when running **CorrectIllumination_Calculate**. You can do this with a pipeline that measures image quality and flags inappropriate images before it runs **CorrectIllumination_Calculate**. """ % globals(), ), ) group.append( "add_measurement_button", cps.DoSomething( "", "Add another measurement", self.add_measurement, group, doc="""Add another measurement as a criteria.""", ), ) self.add_measurement(group, False if not can_delete else True) if can_delete: group.append( "remover", cps.RemoveSettingButton("", "Remove this flag", self.flags, group), ) group.append("divider2", cps.Divider(line=True)) self.flags.append(group)
def create_settings(self): self.objects_or_image = cps.Choice( "Display object or image measurements?", [OI_OBJECTS, OI_IMAGE], doc="""\ - *%(OI_IMAGE)s* allows you to select an image measurement to display for each well. - *%(OI_OBJECTS)s* allows you to select an object measurement to display for each well. """ % globals(), ) self.object = cps.ObjectNameSubscriber( "Select the object whose measurements will be displayed", "None", doc="""\ Choose the name of objects identified by some previous module (such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose measurements are to be displayed. """, ) self.plot_measurement = cps.Measurement( "Select the measurement to plot", self.get_object, "None", doc= """Choose the image or object measurement made by a previous module to plot.""", ) self.plate_name = cps.Measurement( "Select your plate metadata", lambda: cpmeas.IMAGE, "Metadata_Plate", doc="""\ Choose the metadata tag that corresponds to the plate identifier. That is, each plate should have a metadata tag containing a specifier corresponding uniquely to that plate. %(USING_METADATA_HELP_REF)s """ % globals(), ) self.plate_type = cps.Choice( "Multiwell plate format", ["96", "384"], doc="""\ The module assumes that your data is laid out in a multi-well plate format common to high-throughput biological screens. Supported formats are: - *96:* A 96-well plate with 8 rows × 12 columns - *384:* A 384-well plate with 16 rows × 24 columns """, ) self.well_format = cps.Choice( "Well metadata format", [WF_NAME, WF_ROWCOL], doc="""\ - *%(WF_NAME)s* allows you to select an image measurement to display for each well. - *%(WF_ROWCOL)s* allows you to select an object measurement to display for each well. """ % globals(), ) self.well_name = cps.Measurement( "Select your well metadata", lambda: cpmeas.IMAGE, "Metadata_Well", doc="""\ Choose the metadata tag that corresponds to the well identifier. The row-column format of these entries should be an alphabetical character (specifying the plate row), followed by two integer characters (specifying the plate column). For example, a standard format 96-well plate would span from “A1” to “H12”, whereas a 384-well plate (16 rows and 24 columns) would span from well “A01” to well “P24”." %(USING_METADATA_HELP_REF)s """ % globals(), ) self.well_row = cps.Measurement( "Select your well row metadata", lambda: cpmeas.IMAGE, "Metadata_WellRow", doc="""\ Choose the metadata tag that corresponds to the well row identifier, typically specified as an alphabetical character. For example, a standard format 96-well plate would span from row “A” to “H”, whereas a 384-well plate (16 rows and 24 columns) would span from row “A” to “P”. %(USING_METADATA_HELP_REF)s """ % globals(), ) self.well_col = cps.Measurement( "Select your well column metadata", lambda: cpmeas.IMAGE, "Metadata_WellCol", doc="""\ Choose the metadata tag that corresponds to the well column identifier, typically specified with two integer characters. For example, a standard format 96-well plate would span from column “01” to “12”, whereas a 384-well plate (16 rows and 24 columns) would span from column “01” to “24”. %(USING_METADATA_HELP_REF)s """ % globals(), ) self.agg_method = cps.Choice( "How should the values be aggregated?", AGG_NAMES, AGG_NAMES[0], doc="""\ Measurements must be aggregated to a single number for each well so that they can be represented by a color. Options are: - *%(AGG_AVG)s:* Average - *%(AGG_STDEV)s:* Standard deviation - *%(AGG_MEDIAN)s* - *%(AGG_CV)s:* Coefficient of variation, defined as the ratio of the standard deviation to the mean. This is useful for comparing between data sets with different units or widely different means. """ % globals(), ) self.title = cps.Text( "Enter a title for the plot, if desired", "", doc="""\ Enter a title for the plot. If you leave this blank, the title will default to *(cycle N)* where *N* is the current image cycle being executed. """, )
def add_dose_value(self, can_remove=True): """Add a dose value measurement to the list can_delete - set this to False to keep from showing the "remove" button for images that must be present.""" group = cps.SettingsGroup() group.append( "measurement", cps.Measurement( "Select the image measurement describing the treatment dose", lambda: cpmeas.IMAGE, doc="""\ The V and Z’ factors, metrics of assay quality, and the EC50, indicating dose-response, are calculated by this module based on each image being specified as a particular treatment dose. Choose a measurement that gives the dose of some treatment for each of your images. See the help for the previous setting for details.""", ), ) group.append( "log_transform", cps.Binary( "Log-transform the dose values?", False, doc="""\ Select *Yes* if you have dose-response data and you want to log-transform the dose values before fitting a sigmoid curve. Select *No* if your data values indicate only positive vs. negative controls. """ % globals(), ), ) group.append( "wants_save_figure", cps.Binary( """Create dose-response plots?""", False, doc= """Select *Yes* if you want to create and save dose-response plots. You will be asked for information on how to save the plots.""" % globals(), ), ) group.append( "figure_name", cps.Text( "Figure prefix", "", doc="""\ *(Used only when creating dose-response plots)* CellProfiler will create a file name by appending the measurement name to the prefix you enter here. For instance, if you specify a prefix of “Dose\_”, when saving a file related to objects you have chosen (for example, *Cells*) and a particular measurement (for example, *AreaShape_Area*), CellProfiler will save the figure as *Dose_Cells_AreaShape_Area.m*. Leave this setting blank if you do not want a prefix. """, ), ) group.append( "pathname", cps.DirectoryPath( "Output file location", dir_choices=[ cpprefs.DEFAULT_OUTPUT_FOLDER_NAME, cpprefs.DEFAULT_INPUT_FOLDER_NAME, cpprefs.ABSOLUTE_FOLDER_NAME, cpprefs.DEFAULT_OUTPUT_SUBFOLDER_NAME, cpprefs.DEFAULT_INPUT_SUBFOLDER_NAME, ], doc="""\ *(Used only when creating dose-response plots)* This setting lets you choose the folder for the output files. %(IO_FOLDER_CHOICE_HELP_TEXT)s %(IO_WITH_METADATA_HELP_TEXT)s """ % globals(), ), ) group.append("divider", cps.Divider()) group.append( "remover", cps.RemoveSettingButton("", "Remove this dose measurement", self.dose_values, group), ) self.dose_values.append(group)
def create_settings(self): """Create the UI settings for the module""" self.seed_objects_name = cps.ObjectNameSubscriber( "Select the seed objects", "None", doc="""\ Select the previously identified objects that you want to use as the seeds for measuring branches and distances. Branches and trunks are assigned per seed object. Seed objects are typically not single points/pixels but instead are usually objects of varying sizes.""", ) self.image_name = cps.ImageNameSubscriber( "Select the skeletonized image", "None", doc="""\ Select the skeletonized image of the dendrites and/or axons as produced by the **Morph** module’s *Skel* operation.""", ) self.wants_branchpoint_image = cps.Binary( "Retain the branchpoint image?", False, doc="""\ Select "*Yes*" if you want to save the color image of branchpoints and trunks. This is the image that is displayed in the output window for this module.""" % globals(), ) self.branchpoint_image_name = cps.ImageNameProvider( "Name the branchpoint image", "BranchpointImage", doc="""\ *(Used only if a branchpoint image is to be retained)* Enter a name for the branchpoint image here. You can then use this image in a later module, such as **SaveImages**.""", ) self.wants_to_fill_holes = cps.Binary( "Fill small holes?", True, doc="""\ The algorithm reskeletonizes the image and this can leave artifacts caused by small holes in the image prior to skeletonizing. These holes result in false trunks and branchpoints. Select "*Yes*" to fill in these small holes prior to skeletonizing.""" % globals(), ) self.maximum_hole_size = cps.Integer( "Maximum hole size", 10, minval=1, doc="""\ *(Used only when filling small holes)* This is the area of the largest hole to fill, measured in pixels. The algorithm will fill in any hole whose area is this size or smaller.""", ) self.wants_objskeleton_graph = cps.Binary( "Export the skeleton graph relationships?", False, doc="""\ Select "*Yes*" to produce an edge file and a vertex file that gives the relationships between vertices (trunks, branchpoints and endpoints).""" % globals(), ) self.intensity_image_name = cps.ImageNameSubscriber( "Intensity image", "None", doc="""\ Select the image to be used to calculate the total intensity along the edges between the vertices (trunks, branchpoints, and endpoints).""", ) self.directory = cps.DirectoryPath( "File output directory", doc= "Select the directory you want to save the graph relationships to.", dir_choices=[ cpprefs.DEFAULT_OUTPUT_FOLDER_NAME, cpprefs.DEFAULT_INPUT_FOLDER_NAME, cpprefs.ABSOLUTE_FOLDER_NAME, cpprefs.DEFAULT_OUTPUT_SUBFOLDER_NAME, cpprefs.DEFAULT_INPUT_SUBFOLDER_NAME, ], ) self.directory.dir_choice = cpprefs.DEFAULT_OUTPUT_FOLDER_NAME self.vertex_file_name = cps.Text( "Vertex file name", "vertices.csv", doc="""\ *(Used only when exporting graph relationships)* Enter the name of the file that will hold the edge information. You can use metadata tags in the file name. Each line of the file is a row of comma-separated values. The first row is the header; this names the file’s columns. Each subsequent row represents a vertex in the skeleton graph: either a trunk, a branchpoint or an endpoint. The file has the following columns: - *image\_number:* The image number of the associated image. - *vertex\_number:* The number of the vertex within the image. - *i:* The I coordinate of the vertex. - *j:* The J coordinate of the vertex. - *label:* The label of the seed object associated with the vertex. - *kind:* The vertex type, with the following choices: - **T:** Trunk - **B:** Branchpoint - **E:** Endpoint """, ) self.edge_file_name = cps.Text( "Edge file name", "edges.csv", doc="""\ *(Used only when exporting graph relationships)* Enter the name of the file that will hold the edge information. You can use metadata tags in the file name. Each line of the file is a row of comma-separated values. The first row is the header; this names the file’s columns. Each subsequent row represents an edge or connection between two vertices (including between a vertex and itself for certain loops). Note that vertices include trunks, branchpoints, and endpoints. The file has the following columns: - *image\_number:* The image number of the associated image. - *v1:* The zero-based index into the vertex table of the first vertex in the edge. - *v2:* The zero-based index into the vertex table of the second vertex in the edge. - *length:* The number of pixels in the path connecting the two vertices, including both vertex pixels. - *total\_intensity:* The sum of the intensities of the pixels in the edge, including both vertex pixel intensities. """, )