def create_settings(self): self.image_name = cps.ImageNameSubscriber( "Select the input image", "None", doc="""Choose the name of the image to display in the object selection user interface.""", ) self.objects_name = cps.ObjectNameProvider( "Name the objects to be identified", "Cells", doc="""\ What do you want to call the objects that you identify using this module? You can use this name to refer to your objects in subsequent modules.""", )
def create_settings(self): """Create the settings for the module Create the settings for the module during initialization. """ self.secondary_objects_name = cps.ObjectNameSubscriber( "Select the larger identified objects", "None", doc="""\ Select the larger identified objects. This will usually be an object previously identified by an **IdentifySecondaryObjects** module.""", ) self.primary_objects_name = cps.ObjectNameSubscriber( "Select the smaller identified objects", "None", doc="""\ Select the smaller identified objects. This will usually be an object previously identified by an **IdentifyPrimaryObjects** module.""", ) self.subregion_objects_name = cps.ObjectNameProvider( "Name the tertiary objects to be identified", "Cytoplasm", doc="""\ Enter a name for the new tertiary objects. The tertiary objects will consist of the smaller object subtracted from the larger object.""", ) self.shrink_primary = cps.Binary( "Shrink smaller object prior to subtraction?", True, doc="""\ Select *Yes* to shrink the smaller objects by 1 pixel before subtracting them from the larger objects. this approach will ensure that there is always a tertiary object produced, even if it is only 1 pixel wide. If you need alternate amounts of shrinking, use the **ExpandOrShrink** module prior to **IdentifyTertiaryObjects**. Select *No* to subtract the objects directly, which will ensure that no pixels are shared between the primary/secondary/tertiary objects and hence measurements for all three sets of objects will not use the same pixels multiple times. However, this may result in the creation of objects with no area. Measurements can still be made on such objects, but the results will be zero or not-a-number (NaN). """ % globals(), )
def create_settings(self): self.objects_name = cps.ObjectNameSubscriber( "Select the input objects", "None", doc="""\ Select the objects you would like to split or merge (that is, whose object numbers you want to reassign). You can use any objects that were created in previous modules, such as **IdentifyPrimaryObjects** or **IdentifySecondaryObjects**.""", ) self.output_objects_name = cps.ObjectNameProvider( "Name the new objects", "RelabeledNuclei", doc="""\ Enter a name for the objects that have been split or merged (that is, whose numbers have been reassigned). You can use this name in subsequent modules that take objects as inputs.""", ) self.relabel_option = cps.Choice( "Operation", [OPTION_MERGE, OPTION_SPLIT], doc="""\ You can choose one of the following options: - *%(OPTION_MERGE)s:* Assign adjacent or nearby objects the same label based on certain criteria. It can be useful, for example, to merge together touching objects that were incorrectly split into two pieces by an **Identify** module. - *%(OPTION_SPLIT)s:* Assign a unique number to separate objects that currently share the same label. This can occur if you applied certain operations in the **Morph** module to objects.""" % globals(), ) self.merge_option = cps.Choice( "Merging method", [UNIFY_DISTANCE, UNIFY_PARENT], doc="""\ *(Used only with the "%(OPTION_MERGE)s" option)* You can merge objects in one of two ways: - *%(UNIFY_DISTANCE)s:* All objects within a certain pixel radius from each other will be merged. - *%(UNIFY_PARENT)s:* All objects which share the same parent relationship to another object will be merged. This is not to be confused with using the **RelateObjects** module, in which the related objects remain as individual objects. See **RelateObjects** for more details.""" % globals(), ) self.merging_method = cps.Choice( "Output object type", [UM_DISCONNECTED, UM_CONVEX_HULL], doc="""\ *(Used only with the "%(UNIFY_PARENT)s" merging method)* **SplitOrMergeObjects** can either merge the child objects and keep them disconnected or it can find the smallest convex polygon (the convex hull) that encloses all of a parent’s child objects. The convex hull will be truncated to include only those pixels in the parent - in that case it may not truly be convex. Choose *%(UM_DISCONNECTED)s* to leave the children as disconnected pieces. Choose *%(UM_CONVEX_HULL)s* to create an output object that is the convex hull around them all.""" % globals(), ) self.parent_object = cps.Choice( "Select the parent object", ["None"], choices_fn=self.get_parent_choices, doc="""\ Select the parent object that will be used to merge the child objects. Please note the following: - You must have established a parent-child relationship between the objects using a prior **RelateObjects** module. - Primary objects and their associated secondary objects are already in a one-to-one parent-child relationship, so it makes no sense to merge them here.""", ) self.distance_threshold = cps.Integer( "Maximum distance within which to merge objects", 0, minval=0, doc="""\ *(Used only with the "%(OPTION_MERGE)s" option and the "%(UNIFY_DISTANCE)s" method)* Objects that are less than or equal to the distance you enter here, in pixels, will be merged. If you choose zero (the default), only objects that are touching will be merged. Note that *%(OPTION_MERGE)s* will not actually connect or bridge the two objects by adding any new pixels; it simply assigns the same object number to the portions of the object. The new, merged object may therefore consist of two or more unconnected components. If you want to add pixels around objects, see **ExpandOrShrink** or **Morph**.""" % globals(), ) self.wants_image = cps.Binary( "Merge using a grayscale image?", False, doc="""\ *(Used only with the "%(OPTION_MERGE)s" option)* Select *Yes* to use the objects’ intensity features to determine whether two objects should be merged. If you choose to use a grayscale image, *%(OPTION_MERGE)s* will merge two objects only if they are within the distance you have specified *and* certain criteria about the objects within the grayscale image are met.""" % globals(), ) self.image_name = cps.ImageNameSubscriber( "Select the grayscale image to guide merging", "None", doc="""\ *(Used only if a grayscale image is to be used as a guide for merging)* Select the name of an image loaded or created by a previous module.""", ) self.minimum_intensity_fraction = cps.Float( "Minimum intensity fraction", 0.9, minval=0, maxval=1, doc="""\ *(Used only if a grayscale image is to be used as a guide for merging)* Select the minimum acceptable intensity fraction. This will be used as described for the method you choose in the next setting.""", ) self.where_algorithm = cps.Choice( "Method to find object intensity", [CA_CLOSEST_POINT, CA_CENTROIDS], doc="""\ *(Used only if a grayscale image is to be used as a guide for merging)* You can use one of two methods to determine whether two objects should merged, assuming they meet the distance criteria (as specified above): - *%(CA_CENTROIDS)s:* When the module considers merging two objects, this method identifies the centroid of each object, records the intensity value of the dimmer of the two centroids, multiplies this value by the *minimum intensity fraction* to generate a threshold, and draws a line between the centroids. The method will merge the two objects only if the intensity of every point along the line is above the threshold. For instance, if the intensity of one centroid is 0.75 and the other is 0.50 and the *minimum intensity fraction* has been chosen to be 0.9, all points along the line would need to have an intensity of min(0.75, 0.50) \* 0.9 = 0.50 \* 0.9 = 0.45. This method works well for round cells whose maximum intensity is in the center of the cell: a single cell that was incorrectly segmented into two objects will typically not have a dim line between the centroids of the two halves and will be correctly merged. - *%(CA_CLOSEST_POINT)s:* This method is useful for unifying irregularly shaped cells that are connected. It starts by assigning background pixels in the vicinity of the objects to the nearest object. Objects are then merged if each object has background pixels that are: - Within a distance threshold from each object; - Above the minimum intensity fraction of the nearest object pixel; - Adjacent to background pixels assigned to a neighboring object. An example of a feature that satisfies the above constraints is a line of pixels that connects two neighboring objects and is roughly the same intensity as the boundary pixels of both (such as an axon connecting two neurons' soma).""" % globals(), )
def create_settings(self): """Create the settings that control this module""" self.object_name = cps.ObjectNameSubscriber( "Select objects to be masked", "None", doc="""\ Select the objects that will be masked (that is, excluded in whole or in part based on the other settings in the module). You can choose from any objects created by a previous object processing module, such as **IdentifyPrimaryObjects**, **IdentifySecondaryObjects** or **IdentifyTertiaryObjects**. """, ) self.remaining_objects = cps.ObjectNameProvider( "Name the masked objects", "MaskedNuclei", doc="""\ Enter a name for the objects that remain after the masking operation. You can refer to the masked objects in subsequent modules by this name. """, ) self.mask_choice = cps.Choice( "Mask using a region defined by other objects or by binary image?", [MC_OBJECTS, MC_IMAGE], doc="""\ You can mask your objects by defining a region using objects you previously identified in your pipeline (*%(MC_OBJECTS)s*) or by defining a region based on the white regions in a binary image previously loaded or created in your pipeline (*%(MC_IMAGE)s*). """ % globals(), ) self.masking_objects = cps.ObjectNameSubscriber( "Select the masking object", "None", doc="""\ *(Used only if mask is to be made from objects)* Select the objects that will be used to define the masking region. You can choose from any objects created by a previous object processing module, such as **IdentifyPrimaryObjects**, **IdentifySecondaryObjects**, or **IdentifyTertiaryObjects**. """, ) self.masking_image = cps.ImageNameSubscriber( "Select the masking image", "None", doc="""\ *(Used only if mask is to be made from an image)* Select an image that was either loaded or created by a previous module. The image should be a binary image where the white portion of the image is the region(s) you will use for masking. Binary images can be loaded from disk using the **NamesAndTypes** module by selecting “Binary mask” for the image type. You can also create a binary image from a grayscale image using **ApplyThreshold**. """, ) self.wants_inverted_mask = cps.Binary( "Invert the mask?", False, doc="""\ This option reverses the foreground/background relationship of the mask. - Select "*No*" for the mask to be composed of the foreground (white portion) of the masking image or the area within the masking objects. - Select "*Yes*" for the mask to instead be composed of the *background* (black portions) of the masking image or the area *outside* the masking objects. """ % globals(), ) self.overlap_choice = cps.Choice( "Handling of objects that are partially masked", [P_MASK, P_KEEP, P_REMOVE, P_REMOVE_PERCENTAGE], doc="""\ An object might partially overlap the mask region, with pixels both inside and outside the region. **MaskObjects** can handle this in one of three ways: - *%(P_MASK)s:* Choosing this option will reduce the size of partially overlapping objects. The part of the object that overlaps the masking region will be retained. The part of the object that is outside of the masking region will be removed. - *%(P_KEEP)s:* If you choose this option, **MaskObjects** will keep the whole object if any part of it overlaps the masking region. - *%(P_REMOVE)s:* Objects that are partially outside of the masking region will be completely removed if you choose this option. - *%(P_REMOVE_PERCENTAGE)s:* Determine whether to remove or keep an object depending on how much of the object overlaps the masking region. **MaskObjects** will keep an object if at least a certain fraction (which you enter below) of the object falls within the masking region. **MaskObjects** completely removes the object if too little of it overlaps the masking region.""" % globals(), ) self.overlap_fraction = cps.Float( "Fraction of object that must overlap", 0.5, minval=0, maxval=1, doc="""\ *(Used only if removing based on overlap)* Specify the minimum fraction of an object that must overlap the masking region for that object to be retained. For instance, if the fraction is 0.75, then 3/4 of an object must be within the masking region for that object to be retained. """, ) self.retain_or_renumber = cps.Choice( "Numbering of resulting objects", [R_RENUMBER, R_RETAIN], doc="""\ Choose how to number the objects that remain after masking, which controls how remaining objects are associated with their predecessors: - *%(R_RENUMBER)s:* The objects that remain will be renumbered using consecutive numbers. This is a good choice if you do not plan to use measurements from the original objects; your object measurements for the masked objects will not have gaps (where removed objects are missing). - *%(R_RETAIN)s:* The original labels for the objects will be retained. This allows any measurements you make from the masked objects to be directly aligned with measurements you might have made of the original, unmasked objects (or objects directly associated with them). """ % globals(), )
def create_settings(self): """Create the settings for the module Create the settings for the module during initialization. """ self.image_name = cps.ImageNameSubscriber( "Select the input image", "None", doc="""\ The name of a binary image from a previous module. **IdentifyDeadWorms** will use this image to establish the foreground and background for the fitting operation. You can use **ApplyThreshold** to threshold a grayscale image and create the binary mask. You can also use a module such as **IdentifyPrimaryObjects** to label each worm and then use **ConvertObjectsToImage** to make the result a mask. """, ) self.object_name = cps.ObjectNameProvider( "Name the dead worm objects to be identified", "DeadWorms", doc="""\ This is the name for the dead worm objects. You can refer to this name in subsequent modules such as **IdentifySecondaryObjects**""", ) self.worm_width = cps.Integer( "Worm width", 10, minval=1, doc="""\ This is the width (the short axis), measured in pixels, of the diamond used as a template when matching against the worm. It should be less than the width of a worm.""", ) self.worm_length = cps.Integer( "Worm length", 100, minval=1, doc="""\ This is the length (the long axis), measured in pixels, of the diamond used as a template when matching against the worm. It should be less than the length of a worm""", ) self.angle_count = cps.Integer( "Number of angles", 32, minval=1, doc="""\ This is the number of different angles at which the template will be tried. For instance, if there are 12 angles, the template will be rotated by 0°, 15°, 30°, 45° … 165°. The shape is bilaterally symmetric; that is, you will get the same shape after rotating it by 180°. """, ) self.wants_automatic_distance = cps.Binary( "Automatically calculate distance parameters?", True, doc="""\ This setting determines whether or not **IdentifyDeadWorms** automatically calculates the parameters used to determine whether two found-worm centers belong to the same worm. Select "*Yes*" to have **IdentifyDeadWorms** automatically calculate the distance from the worm length and width. Select "*No*" to set the distances manually. """ % globals(), ) self.space_distance = cps.Float( "Spatial distance", 5, minval=1, doc="""\ *(Used only if not automatically calculating distance parameters)* Enter the distance for calculating the worm centers, in units of pixels. The worm centers must be at least many pixels apart for the centers to be considered two separate worms. """, ) self.angular_distance = cps.Float( "Angular distance", 30, minval=1, doc="""\ *(Used only if automatically calculating distance parameters)* **IdentifyDeadWorms** calculates the worm centers at different angles. Two worm centers are considered to represent different worms if their angular distance is larger than this number. The number is measured in degrees. """, )
def create_settings(self): """Create your settings by subclassing this function create_settings is called at the end of initialization. """ self.grid_name = cps.GridNameSubscriber( "Select the defined grid", "None", doc="""Select the name of a grid created by a previous **DefineGrid** module.""", ) self.output_objects_name = cps.ObjectNameProvider( "Name the objects to be identified", "Wells", doc="""\ Enter the name of the grid objects identified by this module. These objects will be available for further measurement and processing in subsequent modules.""", ) self.shape_choice = cps.Choice( "Select object shapes and locations", [SHAPE_RECTANGLE, SHAPE_CIRCLE_FORCED, SHAPE_CIRCLE_NATURAL, SHAPE_NATURAL], doc="""\ Use this setting to choose the method to be used to determine the grid objects’ shapes and locations: - *%(SHAPE_RECTANGLE)s:* Each object will be created as a rectangle, completely occupying the entire grid compartment (rectangle). This option creates the rectangular objects based solely on the grid’s specifications, not on any previously identified guiding objects. - *%(SHAPE_CIRCLE_FORCED)s:* Each object will be created as a circle, centered in the middle of each grid compartment. This option places the circular objects’ locations based solely on the grid’s specifications, not on any previously identified guiding objects. The radius of all circles in a grid will be constant for the entire grid in each image cycle, and can be determined automatically for each image cycle based on the average radius of previously identified guiding objects for that image cycle, or instead it can be specified as a single radius for all circles in all grids in the entire analysis run. - *%(SHAPE_CIRCLE_NATURAL)s:* Each object will be created as a circle, and each circle’s location within its grid compartment will be determined based on the location of any previously identified guiding objects within that grid compartment. Thus, if a guiding object lies within a particular grid compartment, that object’s center will be the center of the created circular object. If no guiding objects lie within a particular grid compartment, the circular object is placed within the center of that grid compartment. If more than one guiding object lies within the grid compartment, they will be combined and the centroid of this combined object will be the location of the created circular object. Note that guiding objects whose centers are close to the grid edge are ignored. - *%(SHAPE_NATURAL)s:* Within each grid compartment, the object will be identified based on combining all of the parts of guiding objects, if any, that fall within the grid compartment. Note that guiding objects whose centers are close to the grid edge are ignored. If a guiding object does not exist within a grid compartment, an object consisting of one single pixel in the middle of the grid compartment will be created. """ % globals(), ) self.diameter_choice = cps.Choice( "Specify the circle diameter automatically?", [AM_AUTOMATIC, AM_MANUAL], doc="""\ *(Used only if "Circle" is selected as object shape)* There are two methods for selecting the circle diameter: - *%(AM_AUTOMATIC)s:* Uses the average diameter of previously identified guiding objects as the diameter. - *%(AM_MANUAL)s:* Lets you specify the diameter directly, as a number. """ % globals(), ) self.diameter = cps.Integer( "Circle diameter", 20, minval=2, doc="""\ *(Used only if "Circle" is selected as object shape and diameter is specified manually)* Enter the diameter to be used for each grid circle, in pixels. %(HELP_ON_MEASURING_DISTANCES)s """ % globals(), ) self.guiding_object_name = cps.ObjectNameSubscriber( "Select the guiding objects", "None", doc="""\ *(Used only if "Circle" is selected as object shape and diameter is specified automatically, or if "Natural Location" is selected as the object shape)* Select the names of previously identified objects that will be used to guide the shape and/or location of the objects created by this module, depending on the method chosen. """, )
def create_settings(self): """Create your settings by subclassing this function create_settings is called at the end of initialization. You should create the setting variables for your module here: # Ask the user for the input image self.image_name = cellprofiler_core.settings.ImageNameSubscriber(...) # Ask the user for the name of the output image self.output_image = cellprofiler_core.settings.ImageNameProvider(...) # Ask the user for a parameter self.smoothing_size = cellprofiler_core.settings.Float(...) """ self.object_name = cps.ObjectNameSubscriber( "Select the objects to be edited", "None", doc="""\ Choose a set of previously identified objects for editing, such as those produced by one of the **Identify** modules (e.g., "*IdentifyPrimaryObjects*", "*IdentifySecondaryObjects*" etc.).""", ) self.filtered_objects = cps.ObjectNameProvider( "Name the edited objects", "EditedObjects", doc="""\ Enter the name for the objects that remain after editing. These objects will be available for use by subsequent modules.""", ) self.allow_overlap = cps.Binary( "Allow overlapping objects?", False, doc="""\ **EditObjectsManually** can allow you to edit an object so that it overlaps another or it can prevent you from overlapping one object with another. Objects such as worms or the neurites of neurons may cross each other and might need to be edited with overlapping allowed, whereas a monolayer of cells might be best edited with overlapping off. Select "*Yes*" to allow overlaps or select "*No*" to prevent them. """ % globals(), ) self.renumber_choice = cps.Choice( "Numbering of the edited objects", [R_RENUMBER, R_RETAIN], doc="""\ Choose how to number the objects that remain after editing, which controls how edited objects are associated with their predecessors: - *%(R_RENUMBER)s:* The module will number the objects that remain using consecutive numbers. This is a good choice if you do not plan to use measurements from the original objects and you only want to use the edited objects in downstream modules; the objects that remain after editing will not have gaps in numbering where removed objects are missing. - *%(R_RETAIN)s:* This option will retain each object’s original number so that the edited object’s number matches its original number. This allows any measurements you make from the edited objects to be directly aligned with measurements you might have made of the original, unedited objects (or objects directly associated with them). """ % globals(), ) self.wants_image_display = cps.Binary( "Display a guiding image?", True, doc="""\ Select "*Yes*" to display an image and outlines of the objects. Select "*No*" if you do not want a guide image while editing. """ % globals(), ) self.image_name = cps.ImageNameSubscriber( "Select the guiding image", "None", doc="""\ *(Used only if a guiding image is desired)* This is the image that will appear when editing objects. Choose an image supplied by a previous module. """, )