def create_settings(self):
self.objects_x = LabelSubscriber(
"Select initial object set",
"None",
doc="""Select an object set which you want to add objects to.""",
)
self.objects_y = LabelSubscriber(
"Select object set to combine",
"None",
doc=
"""Select an object set which you want to add to the initial set.""",
)
self.merge_method = Choice(
"Select how to handle overlapping objects",
choices=["Merge", "Preserve", "Discard", "Segment"],
doc="""\
When combining sets of objects, it is possible that both sets had an object in the
same location. Use this setting to choose how to handle objects which overlap with
eachother.
- Selecting "Merge" will make overlapping objects combine into a single object, taking
on the label of the object from the initial set. When an added object would overlap
with multiple objects from the initial set, each pixel of the added object will be
assigned to the closest object from the initial set. This is primarily useful when
the same objects appear in both sets.
- Selecting "Preserve" will protect the initial object set. Any overlapping regions
from the second set will be ignored in favour of the object from the initial set.
- Selecting "Discard" will only add objects which do not have any overlap with objects
in the initial object set.
- Selecting "Segment" will combine both object sets and attempt to re-draw segmentation to
separate objects which overlapped. Note: This is less reliable when more than
two objects were overlapping. If two object sets genuinely occupy the same space
it may be better to consider them seperately.
""",
)
self.output_object = LabelName(
"Name the combined object set",
"CombinedObjects",
doc="""\
Enter the name for the combined object set. These objects will be available for use in
subsequent modules.""",
)
def add_object_cb(self, can_remove=True):
'''Add an object to the object_groups collection
can_delete - set this to False to keep from showing the "remove"
button for objects that must be present.
'''
group = cps.SettingsGroup()
if can_remove:
group.append("divider", cps.Divider(line=False))
group.append(
'object_name',
LabelSubscriber("Select objects to measure",
"None",
doc="""
What did you call the objects from which you want to calculate moments?
If you only want to calculat moments of
the image overall, you can remove all objects using the "Remove this object" button.
<p>Objects specified here will have moments computed against <i>all</i> images specfied above, which
may lead to image-object combinations that are unneccesary. If you
do not want this behavior, use multiple <b>CalculateMoments</b>
modules to specify the particular image-object measures that you want.</p>"""
))
if can_remove:
group.append(
"remover",
cps.do_something.RemoveSettingButton("", "Remove this object",
self.object_groups,
group))
self.object_groups.append(group)
def create_settings(self):
self.input_object_name = LabelSubscriber(
"Select objects to measure",
"None",
doc=
"""Select the objects whose radial entropy you want to measure.""")
self.input_image_name = ImageSubscriber("Select an image to measure",
"None",
doc="""Select the
grayscale image you want to measure the entropy of.""")
self.bin_number = Integer(
"Input number of bins",
6,
minval=3,
maxval=60,
doc=
"""Number of radial bins to divide your object into. The minimum number
of bins allowed is 3, the maximum number is 60.""")
self.intensity_measurement = Choice(
"Which intensity measurement should be used?",
['Mean', 'Median', 'Integrated'],
value='Mean',
doc="""
Whether each wedge's mean, median, or integrated intensity
should be used to calculate the entropy.""")
def __init__(self, index, operation):
self.__index = index
self.__operation = operation
self.__operand_choice = Choice(
self.operand_choice_text(),
MC_ALL,
doc="""Indicate whether the operand is an image or object measurement.""",
)
self.__operand_objects = LabelSubscriber(
self.operand_objects_text(),
"None",
doc="""Choose the objects you want to measure for this operation.""",
)
self.__operand_measurement = Measurement(
self.operand_measurement_text(),
self.object_fn,
doc="""\
Enter the category that was used to create the measurement. You
will be prompted to add additional information depending on
the type of measurement that is requested.""",
)
self.__multiplicand = Float(
"Multiply the above operand by",
1,
doc="""Enter the number by which you would like to multiply the above operand.""",
)
self.__exponent = Float(
"Raise the power of above operand by",
1,
doc="""Enter the power by which you would like to raise the above operand.""",
)
def create_settings(self):
super(FindMaxima, self).create_settings()
self.min_distance = Integer(
text="Minimum distance between maxima",
value=5,
minval=0,
doc="""Choose the minimum distance between accepted local maxima"""
)
self.exclude_mode = Choice("Method for excluding background",
[MODE_THRESHOLD, MODE_MASK, MODE_OBJECTS],
value="Threshold",
doc=f"""\
By default, local maxima will be searched for across the whole image. This means that maxima will be found in
areas that consist entirely of background. To resolve this we have several methods to exclude background.
**{MODE_THRESHOLD}** allows you to specify a minimum pixel intensity to be considered as a peak. Setting this to 0
effectively uses no threshold.
**{MODE_MASK}** will restrict peaks to areas which are within a provided mask image. This mask will typically come from
the threshold module or another means of finding background.
**{MODE_OBJECTS}** will restrict peaks to areas within an existing set of objects.
""")
self.min_intensity = Float("Specify the minimum intensity of a peak",
0,
minval=0,
maxval=99,
doc="""\
Intensity peaks below this threshold value will be excluded. Use this to ensure that your local
maxima are within objects of interest.""")
self.mask_image = ImageSubscriber(
"Select the image to use as a mask",
doc=
"Select the image you want to use. This should be a binary image.")
self.mask_objects = LabelSubscriber(
"Select the objects to search within",
doc="Select the objects within which to search for peaks.")
self.maxima_color = Color(
"Select maxima preview color",
"Blue",
doc="Maxima will be displayed in this color.",
)
self.maxima_size = Integer(
"Select maxima preview size",
value=1,
minval=1,
doc=
"Size of the markers for each maxima in the preview. Positive pixels will be"
"expanded by this radius."
"You may want to increase this when working with large images.",
)
self.spacer = Divider(line=True)
def create_settings(self):
super(OverlayObjects, self).create_settings()
self.x_name.text = "Input"
self.x_name.doc = "Objects will be overlaid on this image."
self.y_name.doc = (
"An RGB image with color-coded labels overlaid on a grayscale image."
)
self.objects = LabelSubscriber(
text="Objects",
doc="Color-coded labels of this object will be overlaid on the input image.",
)
self.opacity = Float(
text="Opacity",
value=0.3,
minval=0.0,
maxval=1.0,
doc="""
Opacity of overlaid labels. Increase this value to decrease the transparency of the colorized object
labels.
""",
)
def create_settings(self):
self.object_name = LabelSubscriber(
"Input objects",
"None",
doc="""Enter the name of the objects whose population context is
to be measured.""")
self.operation = Choice(
"Operation",
choices=(O_POPULATION_DENSITY, O_DISTANCE_TO_EDGE, O_BOTH),
doc="""Select the measurements you wish to perform. The choices
are:<br><ul>
<li><i>%(O_POPULATION_DENSITY)s</i> - calculate the population
density within a radius from each cell.</li>
<li><i>%(O_DISTANCE_TO_EDGE)s</i> - calculate the distance of
each cell from the edge of a binary mask.</li>
<li><i>%(O_BOTH)s</i> - make both measurements""" % globals())
self.radius = Integer("Search radius",
50,
minval=1,
doc="""Count all objects within this radius""")
self.object_diameter = Integer(
"Object diameter",
20,
minval=0,
doc="""The average diameter of objects in the image. This number
is used to adjust the area of the image to account for objects
that would otherwise be excluded because they were touching
the border.""")
self.edge_image = ImageSubscriber(
"Edge image",
doc="""For measuring distance to an edge, this is the reference
image. Cell distances will be computed to the nearest foreground /
background edge in the reference image.""")
def create_settings(self):
"""Create the settings for the module
Create the settings for the module during initialization.
"""
self.secondary_objects_name = LabelSubscriber(
"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 = LabelSubscriber(
"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 = LabelName(
"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 = 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.object_name = LabelSubscriber(
"Select the input objects",
"None",
doc=
"Choose the name of the objects you want to convert to an image.",
)
self.image_name = ImageName(
"Name the output image",
"CellImage",
doc="Enter the name of the resulting image.",
)
self.image_mode = Choice(
"Select the color format",
["Color", "Binary (black & white)", "Grayscale", "uint16"],
doc="""\
Select which colors the resulting image should use. You have the
following options:
- *Color:* Allows you to choose a colormap that will produce jumbled
colors for your objects.
- *Binary (black & white):* All object pixels will be assigned 1 and
all background pixels will be assigned 0, creating a binary image.
- *Grayscale:* Assigns all background pixels to 0 and assigns each object's pixels with a number
specific to that object. Object numbers can range from 1 to 255 (the maximum value that you can put
in an 8-bit integer, use **uint16** if you expect more than 255 objects).
This creates an image where objects in the top left corner of the image are
very dark and the colors progress to white toward the bottom right corner of the image.
Use **SaveImages** to save the resulting image as a .npy file or .tiff file if you want
to process the label matrix image using another program or in a separate CellProfiler pipeline.
- *uint16:* Assigns all background pixels to 0 and assigns each object's pixels with a number
specific to that object. Object numbers can range from 1 to 65535 (the maximum value that you can put
in a 16-bit integer). This creates an image where objects in the top left corner of the image are
very dark and where the colors progress to white toward the bottom right corner of the image
(though this can usually only be seen in a scientific image viewer since standard image viewers only
handle 8-bit images). Use **SaveImages** to save the resulting image as a .npy file or
**16-bit** (not 8-bit!) .tiff file if you want to process the label matrix image using another
program or in a separate CellProfiler pipeline.
You can choose *Color* with a *Gray* colormap to produce jumbled gray
objects.
""",
)
self.colormap = Colormap(
"Select the colormap",
doc="""\
*(Used only if "Color" output image selected)*
Choose the colormap to be used, which affects how the objects are
colored. You can look up your default colormap under *File >
Preferences*.
""",
)
def create_settings(self):
#
# The ImageNameSubscriber "subscribes" to all ImageNameProviders in
# prior modules. Modules before yours will put images into CellProfiler.
# The ImageSubscriber gives your user a list of these images
# which can then be used as inputs in your module.
#
self.input_image_name = ImageSubscriber(
# The text to the left of the edit box
text="Input image name:",
# reST help that gets displayed when the user presses the
# help button to the right of the edit box.
doc="""\
This is the image that the module operates on. You can choose any image
that is made available by a prior module.
**MeasurementTemplate** will measure something about this image.
""",
)
#
# The ObjectNameSubscriber is similar to the ImageNameSubscriber.
# It will ask the user which object to pick from the list of
# objects provided by upstream modules.
#
self.input_object_name = LabelSubscriber(
text="Input object name",
doc="These are the objects that the module operates on.",
)
#
# The radial degree is the "N" parameter in the Zernike - how many
# inflection points there are, radiating out from the center. Higher
# N means more features and a more detailed description
#
# The setting is an integer setting, bounded between 1 and 50.
# N = 50 generates 1200 features!
#
self.radial_degree = Integer(
text="Radial degree",
value=10,
minval=1,
maxval=50,
doc="""\
Calculate all Zernike features up to the given radial
degree. The Zernike function is parameterized by a radial
and azimuthal degree. The module will calculate all Zernike
features for all azimuthal degrees up to and including the
radial degree you enter here.
""",
)
def add_objects(self, can_delete=True):
group = cps.SettingsGroup()
self.objects_to_export.append(group)
group.append(
"objects_name",
LabelSubscriber("Objects name",
value="Nuclei",
doc="""
This setting lets you choose the objects you want to export.
<b>ExportToCellH5</b> will write the segmentation of the objects
to your CellH5 file so that they can be saved and used by other
applications that support the format.
"""))
group.append(
"Remover",
cps.do_something.RemoveSettingButton("Remove the objects above",
"Remove",
self.objects_to_export,
group))
def create_settings(self):
# choose the tracked objects to measure TrAM on
self.object_name = LabelSubscriber(
"Tracked objects", "None", doc="""
Select the tracked objects for computing TrAM.""")
# which measurements will go into the TrAM computation
self.tram_measurements = MeasurementMultiChoiceForCategory(
"TrAM measurements", category_chooser=self.object_name, doc="""
These are measurements for the selected tracked objects which
will be used in the TrAM computation. At least one must be selected.""")
# Treat X-Y value pairs as isotropic in the TrAM measure?
self.isotropic = cps.Binary(
'Isotropic XY metric?', True, doc="""
If selected (the default) then measurements that are available
as X-Y pairs (e.g. location) will be have an isotropic
metric applied in TrAM. Note that the X-Y-Z extension of this feature
is not currently available.
""")
# number of spline knots
self.num_knots = Integer(
"Number of spline knots", 4, minval=self.MIN_NUM_KNOTS, doc="""
The number of knots (indpendent values) used
when computing smoothing splines. This should be around 1/5th the number
of frames for reasonably oversampled time lapse sequences, and must be 3
or greater. It is approximately the maximum number of wiggles expected in
well-tracked trajectories
""")
# TrAM exponent
self.tram_exponent = Float(
"TrAM exponent", 0.5, minval=0.01, maxval=1.0, doc="""
This number is between 0.01 and 1 (default 0.5), and specifies how
strongly simultaneous sudden changes in multiple features synergize in
the TrAM metric. A lower value signifies higher synergy (at the risk of
missing tracking failures that are reflected in only some of the features).
""")
def add_additional_object(self):
group = SettingsGroup()
group.append(
"object_name",
LabelSubscriber("Select additional object to relabel", "None"),
)
group.append(
"target_name", LabelName("Name the relabeled objects", "FilteredGreen"),
)
group.append(
"remover",
RemoveSettingButton(
"", "Remove this additional object", self.additional_objects, group
),
)
group.append("divider", Divider(line=False))
self.additional_objects.append(group)
def create_settings(self):
super(ConstrainObjects, self).create_settings()
self.reference_name = LabelSubscriber(
text="Constraining Objects",
doc="Objects to use as reference for the constraint")
self.coersion_method = Choice(
text="Handle protruding objects",
choices=[METHOD_IGNORE, METHOD_REMOVE],
value=METHOD_IGNORE,
doc="""\
Assuming the objects are related, there may be some "child" objects
that protrude into the space of a "parent" object with a different label.
E.g. a nuclei from one cell may protrude into the membrane segmentation
of a difference cell. This method sets how to handle these cases
**{METHOD_IGNORE}**: Ignore these protrusions, only constrain the real child
**{METHOD_REMOVE}**: Remove the portion of the child that protrudes into the wrong parent
""".format(**{
"METHOD_IGNORE": METHOD_IGNORE,
"METHOD_REMOVE": METHOD_REMOVE
}))
self.remove_orphans = cellprofiler_core.setting.Binary(
text="Remove children without a corresponding parent",
value=False,
doc="""
Some objects may be "parent-less" orphans, e.g. nuclei segmentations that have no
corresponding, surrounding membrane segmentations. This specifies how to handle these
objects.
**{NO}**: Ignore them
**{YES}**: Remove the entire object from set
""".format(**{
"YES": "Yes",
"NO": "No"
}))
def create_settings(self):
self.export_option = Choice(
"Do you want to save cropped images or object masks?",
[SAVE_PER_OBJECT, SAVE_MASK],
doc="""\
Choose the way you want the per-object crops to be exported.
The choices are:
- *{SAVE_PER_OBJECT}*: Save a per-object crop from the original image
based on the object's bounding box.
- *{SAVE_MASK}*: Export a per-object mask.""".format(
SAVE_PER_OBJECT=SAVE_PER_OBJECT, SAVE_MASK=SAVE_MASK),
)
self.objects_name = LabelSubscriber(
"Objects",
doc="Select the objects you want to export as per-object crops.")
self.image_name = ImageSubscriber("Image",
doc="Select the image to crop")
self.directory = Directory(
"Directory",
doc="Enter the directory where object crops are saved.",
value=DEFAULT_OUTPUT_FOLDER_NAME,
)
self.file_format = Choice(
"Saved file format",
[O_PNG, O_TIFF_8, O_TIFF_16],
value=O_TIFF_8,
doc="""\
**{O_PNG}** files do not support 3D. **{O_TIFF_8}** files use zlib compression level 6."""
.format(O_PNG=O_PNG, O_TIFF_8=O_TIFF_8, O_TIFF_16=O_TIFF_16),
)
def add_outline(self, can_remove=True):
group = SettingsGroup()
if can_remove:
group.append("divider", Divider(line=False))
group.append(
"objects_name",
LabelSubscriber(
"Select objects to display",
"None",
doc="Choose the objects whose outlines you would like to display.",
),
)
default_color = (
COLOR_ORDER[len(self.outlines)]
if len(self.outlines) < len(COLOR_ORDER)
else COLOR_ORDER[0]
)
group.append(
"color",
Color(
"Select outline color",
default_color,
doc="Objects will be outlined in this color.",
),
)
if can_remove:
group.append(
"remover",
RemoveSettingButton("", "Remove this outline", self.outlines, group),
)
self.outlines.append(group)
def create_settings(self):
super(ObjectProcessing, self).create_settings()
self.x_name = LabelSubscriber("Select the input object",
doc="Select the object you want to use.")
def create_settings(self):
"""Create the settings here and set the module name (initialization)
"""
self.source_choice = Choice(
"Use objects or an image as a mask?",
[IO_OBJECTS, IO_IMAGE],
doc="""\
You can mask an image in two ways:
- *%(IO_OBJECTS)s*: Using objects created by another module (for
instance **IdentifyPrimaryObjects**). The module will mask out all
parts of the image that are not within one of the objects (unless you
invert the mask).
- *%(IO_IMAGE)s*: Using a binary image as the mask, where black
portions of the image (false or zero-value pixels) will be masked
out. If the image is not binary, the module will use all pixels whose
intensity is greater than 0.5 as the mask’s foreground (white area).
You can use **Threshold** instead to create a binary image with
finer control over the intensity choice.
""" % globals(),
)
self.object_name = LabelSubscriber(
"Select object for mask",
"None",
doc="""\
*(Used only if mask is to be made from objects)*
Select the objects you would like to use to mask the input image.
""",
)
self.masking_image_name = ImageSubscriber(
"Select image for mask",
"None",
doc="""\
*(Used only if mask is to be made from an image)*
Select the image that you like to use to mask the input image.
""",
)
self.image_name = ImageSubscriber(
"Select the input image",
"None",
doc="Select the image that you want to mask.",
)
self.masked_image_name = ImageName(
"Name the output image",
"MaskBlue",
doc="Enter the name for the output masked image.",
)
self.invert_mask = Binary(
"Invert the mask?",
False,
doc="""\
This option reverses the foreground/background relationship of the mask.
- Select "*No*" to produce the mask from the foreground (white
portion) of the masking image or the area within the masking objects.
- Select "*Yes*" to instead produce the mask from the *background*
(black portions) of the masking image or the area *outside* the
masking objects.
""" % globals(),
)
def create_settings(self):
super(RelateObjects, self).create_settings()
self.x_name.text = "Parent objects"
self.x_name.doc = """\
Parent objects are defined as those objects which encompass the child object.
For example, when relating speckles to the nuclei that contain them,
the nuclei are the parents.
"""
self.y_name = LabelSubscriber(
"Child objects",
doc="""\
Child objects are defined as those objects contained within the parent object. For example, when relating
speckles to the nuclei that contains them, the speckles are the children.
""",
)
self.find_parent_child_distances = Choice(
"Calculate child-parent distances?",
D_ALL,
doc="""\
Choose the method to calculate distances of each child to its parent.
For example, these measurements can tell you whether nuclear speckles
are located more closely to the center of the nucleus or to the nuclear
periphery.
- *{D_NONE}:* Do not calculate any distances. This saves computation time.
- *{D_MINIMUM}:* The distance from the centroid of the child object to
the closest perimeter point on the parent object.
- *{D_CENTROID}:* The distance from the centroid of the child object
to the centroid of the parent.
- *{D_BOTH}:* Calculate both the *{D_MINIMUM}* and *{D_CENTROID}*
distances.""".format(
**{
"D_NONE": D_NONE,
"D_MINIMUM": D_MINIMUM,
"D_CENTROID": D_CENTROID,
"D_BOTH": D_BOTH,
}),
)
self.wants_step_parent_distances = Binary(
"Calculate distances to other parents?",
False,
doc="""\
*(Used only if calculating distances)*
Select "*{YES}*" to calculate the distances of the child objects to some
other objects. These objects must be either parents or children of your
parent object in order for this module to determine the distances. For
instance, you might find “Nuclei” using **IdentifyPrimaryObjects**, find
“Cells” using **IdentifySecondaryObjects** and find “Cytoplasm” using
**IdentifyTertiaryObjects**. You can use **Relate** to relate speckles
to cells and then measure distances to nuclei and cytoplasm. You could
not use **RelateObjects** to relate speckles to cytoplasm and then
measure distances to nuclei, because nuclei are neither a direct parent
nor child of cytoplasm.""".format(**{"YES": "Yes"}),
)
self.step_parent_names = []
self.add_step_parent(can_delete=False)
self.add_step_parent_button = DoSomething("", "Add another parent",
self.add_step_parent)
self.wants_per_parent_means = Binary(
"Calculate per-parent means for all child measurements?",
False,
doc="""\
Select "*{YES}*" to calculate the per-parent mean values of every upstream
measurement made with the children objects and store them as a
measurement for the parent; the nomenclature of this new measurement is
“Mean_<child>_<category>_<feature>”. This module
must be placed *after* all **Measure** modules that make measurements
of the children objects.""".format(**{"YES": "Yes"}),
)
self.wants_child_objects_saved = Binary(
"Do you want to save the children with parents as a new object set?",
False,
doc="""\
Select "*{YES}*" to save the children objects that do have parents as new
object set. Objects with no parents will be discarded""".format(
**{"YES": "Yes"}),
)
self.output_child_objects_name = LabelName(
"Name the output object",
"RelateObjects",
doc="""\
Enter the name you want to call the object produced by this module. """,
)
def create_settings(self):
"""Create your settings by subclassing this function
create_settings is called at the end of initialization.
"""
self.grid_name = GridSubscriber(
"Select the defined grid",
"None",
doc=
"""Select the name of a grid created by a previous **DefineGrid** module.""",
)
self.output_objects_name = LabelName(
"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 = 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 = 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 = 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.
{dist}
""".format(dist=HELP_ON_MEASURING_DISTANCES),
)
self.guiding_object_name = LabelSubscriber(
"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):
self.object_name = LabelSubscriber(
"Select objects to measure",
"None",
doc="""\
Select the objects whose neighbors you want to measure.""",
)
self.neighbors_name = LabelSubscriber(
"Select neighboring objects to measure",
"None",
doc="""\
This is the name of the objects that are potential
neighbors of the above objects. You can find the neighbors
within the same set of objects by selecting the same objects
as above.""",
)
self.distance_method = Choice(
"Method to determine neighbors",
D_ALL,
D_EXPAND,
doc="""\
There are several methods by which to determine whether objects are
neighbors:
- *%(D_ADJACENT)s:* In this mode, two objects must have adjacent
boundary pixels to be neighbors.
- *%(D_EXPAND)s:* The objects are expanded until all pixels on the
object boundaries are touching another. Two objects are neighbors if
any of their boundary pixels are adjacent after expansion.
- *%(D_WITHIN)s:* Each object is expanded by the number of pixels you
specify. Two objects are neighbors if they have adjacent pixels after
expansion.
For *%(D_ADJACENT)s* and *%(D_EXPAND)s*, the
*%(M_PERCENT_TOUCHING)s* measurement is the percentage of pixels on
the boundary of an object that touch adjacent objects. For
*%(D_WITHIN)s*, two objects are touching if any of their boundary
pixels are adjacent after expansion and *%(M_PERCENT_TOUCHING)s*
measures the percentage of boundary pixels of an *expanded* object that
touch adjacent objects.
""" % globals(),
)
self.distance = Integer(
"Neighbor distance",
5,
1,
doc="""\
*(Used only when “%(D_WITHIN)s” is selected)*
The Neighbor distance is the number of pixels that each object is
expanded for the neighbor calculation. Expanded objects that touch are
considered neighbors.
""" % globals(),
)
self.wants_count_image = Binary(
"Retain the image of objects colored by numbers of neighbors?",
False,
doc="""\
An output image showing the input objects colored by numbers of
neighbors may be retained. A colormap of your choice shows how many
neighbors each object has. The background is set to -1. Objects are
colored with an increasing color value corresponding to the number of
neighbors, such that objects with no neighbors are given a color
corresponding to 0. Use the **SaveImages** module to save this image to
a file.""",
)
self.count_image_name = ImageName(
"Name the output image",
"ObjectNeighborCount",
doc="""\
*(Used only if the image of objects colored by numbers of neighbors is
to be retained for later use in the pipeline)*
Specify a name that will allow the image of objects colored by numbers
of neighbors to be selected later in the pipeline.""",
)
self.count_colormap = Colormap(
"Select colormap",
value="Blues",
doc="""\
*(Used only if the image of objects colored by numbers of neighbors is
to be retained for later use in the pipeline)*
Select the colormap to use to color the neighbor number image. All
available colormaps can be seen `here`_.
.. _here: http://matplotlib.org/examples/color/colormaps_reference.html""",
)
self.wants_percent_touching_image = Binary(
"Retain the image of objects colored by percent of touching pixels?",
False,
doc="""\
Select *Yes* to keep an image of the input objects colored by the
percentage of the boundary touching their neighbors. A colormap of your
choice is used to show the touching percentage of each object. Use the
**SaveImages** module to save this image to a file.
""" % globals(),
)
self.touching_image_name = ImageName(
"Name the output image",
"PercentTouching",
doc="""\
*(Used only if the image of objects colored by percent touching is to be
retained for later use in the pipeline)*
Specify a name that will allow the image of objects colored by percent
of touching pixels to be selected later in the pipeline.""",
)
self.touching_colormap = Colormap(
"Select colormap",
value="Oranges",
doc="""\
*(Used only if the image of objects colored by percent touching is to be
retained for later use in the pipeline)*
Select the colormap to use to color the percent touching image. All
available colormaps can be seen `here`_.
.. _here: http://matplotlib.org/examples/color/colormaps_reference.html""",
)
self.wants_excluded_objects = Binary(
"Consider objects discarded for touching image border?",
True,
doc="""\
When set to *{YES}*, objects which were previously discarded for touching
the image borders will be considered as potential object neighbours in this
analysis. You may want to disable this if using object sets which were
further filtered, since those filters won't have been applied to the
previously discarded objects.""".format(**{"YES": "Yes"}),
)
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 = .ImageSubscriber(...)
# Ask the user for the name of the output image
self.output_image = .ImageName(...)
# Ask the user for a parameter
self.smoothing_size = .Float(...)
"""
self.object_name = LabelSubscriber(
"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 = LabelName(
"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 = 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 = 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 = 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 = ImageSubscriber(
"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.
""",
)
def create_settings(self):
self.x_object = LabelSubscriber(
"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 = 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 = LabelSubscriber(
"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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 create_settings(self):
self.objects_name = LabelSubscriber(
"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 = LabelName(
"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 = 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 = 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 = 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 = 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 = 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 = 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 = ImageSubscriber(
"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 = 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 = 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 add_measurement(self, flag_settings, can_delete=True):
measurement_settings = flag_settings.measurement_settings
group = SettingsGroup()
group.append("divider1", Divider(line=False))
group.append(
"source_choice",
Choice(
"Flag is based on",
S_ALL,
doc="""\
- *%(S_IMAGE)s:* A per-image measurement, such as intensity or
granularity.
- *%(S_AVERAGE_OBJECT)s:* The average of all object measurements in
the image.
- *%(S_ALL_OBJECTS)s:* All the object measurements in an image,
without averaging. In other words, if *any* of the objects meet the
criteria, the image will be flagged.
- *%(S_RULES)s:* Use a text file of rules produced by CellProfiler
Analyst. With this option, you will have to ensure that this pipeline
produces every measurement in the rules file upstream of this module.
- *%(S_CLASSIFIER)s:* Use a classifier built by CellProfiler Analyst.
""" % globals(),
),
)
group.append(
"object_name",
LabelSubscriber(
"Select the object to be used for flagging",
"None",
doc="""\
*(Used only when flag is based on an object measurement)*
Select the objects whose measurements you want to use for flagging.
""",
),
)
def object_fn():
if group.source_choice == S_IMAGE:
return IMAGE
return group.object_name.value
group.append(
"rules_directory",
Directory(
"Rules file location",
doc="""\
*(Used only when flagging using "{rules}")*
Select the location of the rules file that will be used for flagging images.
{folder_choice}
""".format(rules=S_RULES, folder_choice=IO_FOLDER_CHOICE_HELP_TEXT),
),
)
def get_directory_fn():
"""Get the directory for the rules file name"""
return group.rules_directory.get_absolute_path()
def set_directory_fn(path):
dir_choice, custom_path = group.rules_directory.get_parts_from_path(
path)
group.rules_directory.join_parts(dir_choice, custom_path)
group.append(
"rules_file_name",
Filename(
"Rules file name",
"rules.txt",
get_directory_fn=get_directory_fn,
set_directory_fn=set_directory_fn,
doc="""\
*(Used only when flagging using "%(S_RULES)s")*
The name of the rules file, most commonly from CellProfiler Analyst's
Classifier. This file should be a plain text file
containing the complete set of rules.
Each line of this file should be a rule naming a measurement to be made
on an image, for instance:
IF (Image_ImageQuality_PowerLogLogSlope_DNA < -2.5, [0.79, -0.79], [-0.94, 0.94])
The above rule will score +0.79 for the positive category and -0.94
for the negative category for images whose power log slope is less
than -2.5 pixels and will score the opposite for images whose slope is
larger. The filter adds positive and negative and flags the images
whose positive score is higher than the negative score.
""" % globals(),
),
)
def get_rules_class_choices(group=group):
"""Get the available choices from the rules file"""
try:
if group.source_choice == S_CLASSIFIER:
return self.get_bin_labels(group)
elif group.source_choice == S_RULES:
rules = self.get_rules(group)
nclasses = len(rules.rules[0].weights[0])
return [str(i) for i in range(1, nclasses + 1)]
else:
return ["None"]
rules = self.get_rules(group)
nclasses = len(rules.rules[0].weights[0])
return [str(i) for i in range(1, nclasses + 1)]
except:
return [str(i) for i in range(1, 3)]
group.append(
"rules_class",
MultiChoice(
"Class number",
choices=["1", "2"],
doc="""\
*(Used only when flagging using "%(S_RULES)s")*
Select which classes to flag when filtering. The CellProfiler Analyst
Classifier user interface lists the names of the classes in order. By
default, these are the positive (class 1) and negative (class 2)
classes. **FlagImage** uses the first class from CellProfiler Analyst
if you choose “1”, etc.
Please note the following:
- The flag is set if the image falls into the selected class.
- You can make multiple class selections. If you do so, the module will
set the flag if the image falls into any of the selected classes.
""" % globals(),
),
)
group.rules_class.get_choices = get_rules_class_choices
group.append(
"measurement",
Measurement(
"Which measurement?",
object_fn,
doc="""Choose the measurement to be used as criteria.""",
),
)
group.append(
"wants_minimum",
Binary(
"Flag images based on low values?",
True,
doc="""\
Select *Yes* to flag images with measurements below the specified
cutoff. If the measurement evaluates to Not-A-Number (NaN), then the
image is not flagged.
""" % globals(),
),
)
group.append(
"minimum_value",
Float("Minimum value", 0, doc="""Set a value as a lower limit."""),
)
group.append(
"wants_maximum",
Binary(
"Flag images based on high values?",
True,
doc="""\
Select *Yes* to flag images with measurements above the specified
cutoff. If the measurement evaluates to Not-A-Number (NaN), then the
image is not flagged.
""" % globals(),
),
)
group.append(
"maximum_value",
Float("Maximum value", 1,
doc="""Set a value as an upper limit."""),
)
if can_delete:
group.append(
"remover",
RemoveSettingButton("", "Remove this measurement",
measurement_settings, group),
)
group.append("divider2", Divider(line=True))
measurement_settings.append(group)
def create_settings(self):
"""Create your settings by subclassing this function
create_settings is called at the end of initialization.
"""
self.grid_image = GridName(
"Name the grid",
doc="""\
This is the name of the grid. You can use this name to
retrieve the grid in subsequent modules.""",
)
self.grid_rows = Integer(
"Number of rows",
8,
1,
doc="""Along the height of the grid, define the number of rows.""",
)
self.grid_columns = Integer(
"Number of columns",
12,
1,
doc=
"""Along the width of the grid, define the number of columns.""",
)
self.origin = Choice(
"Location of the first spot",
[NUM_TOP_LEFT, NUM_BOTTOM_LEFT, NUM_TOP_RIGHT, NUM_BOTTOM_RIGHT],
doc="""\
Grid cells are numbered consecutively; this option identifies the
origin for the numbering system and the direction for numbering.
For instance, if you choose "*%(NUM_TOP_LEFT)s*", the top left cell is
cell #1 and cells to the right and bottom are indexed with
larger numbers.""" % globals(),
)
self.ordering = Choice(
"Order of the spots",
[NUM_BY_ROWS, NUM_BY_COLUMNS],
doc="""\
Grid cells can either be numbered by rows, then columns or by columns,
then rows. For instance, if you asked to start numbering a 96-well
plate at the top left (by specifying the location of the first spot), then:
- *%(NUM_BY_ROWS)s:* this option will give well A01 the index 1, B01
the index 2, and so on up to H01 which receives the index 8. Well A02
will be assigned the index 9.
- *%(NUM_BY_COLUMNS)s:* with this option, the well A02 will be
assigned 2, well A12 will be assigned 12 and well B01 will be
assigned 13.
""" % globals(),
)
self.each_or_once = Choice(
"Define a grid for which cycle?",
[EO_EACH, EO_ONCE],
doc="""\
The setting allows you choose when you want to define a new grid:
- *%(EO_ONCE)s:* If all of your images are perfectly aligned with each
other (due to very consistent image acquisition, consistent grid
location within the plate, and/or automatic cropping precisely within
each plate), you can define the location of the marker spots once for
all of the image cycles.
- *%(EO_EACH)s:* If the location of the grid will vary from one image
cycle to the next then you should define the location of the marker
spots for each cycle independently.
""" % globals(),
)
self.auto_or_manual = Choice(
"Select the method to define the grid",
[AM_AUTOMATIC, AM_MANUAL],
doc="""\
Select whether you would like to define the grid automatically (based on
objects you have identified in a previous module) or manually. This
setting controls how the grid is defined:
- *%(AM_MANUAL)s:* In manual mode, you manually indicate known
locations of marker spots in the grid and have the rest of the
positions calculated from those marks, no matter what the image
itself looks like. You can define the grid either by clicking on the
image with a mouse or by entering coordinates.
- *%(AM_AUTOMATIC)s:* If you would like the grid to be defined
automatically, an **IdentifyPrimaryObjects** module must be run prior
to this module to identify the objects that will be used to define
the grid. The left-most, right-most, top-most, and bottom-most object
will be used to define the edges of the grid, and the rows and
columns will be evenly spaced between these edges. Note that
Automatic mode requires that the incoming objects are nicely defined:
for example, if there is an object at the edge of the images that is
not really an object that ought to be in the grid, a skewed grid will
result. You might wish to use a **FilterObjects** module to clean up
badly identified objects prior to defining the grid. If the spots are
slightly out of alignment with each other from one image cycle to the
next, this allows the identification to be a bit flexible and adapt
to the real location of the spots.
""" % globals(),
)
self.object_name = LabelSubscriber(
"Select the previously identified objects",
"None",
doc="""\
*(Used only if you selected "%(AM_AUTOMATIC)s" to define the grid)*
Select the previously identified objects you want to use to define the
grid. Use this setting to specify the name of the objects that will be
used to define the grid.
""" % globals(),
)
self.manual_choice = Choice(
"Select the method to define the grid manually",
[MAN_MOUSE, MAN_COORDINATES],
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" to define the grid)*
Specify whether you want to define the grid using the mouse or by
entering the coordinates of the cells.
- *%(MAN_MOUSE)s:* The user interface displays the image you specify.
You will be asked to click in the center of two of the grid cells and
specify the row and column for each. The grid coordinates will be
computed from this information.
- *%(MAN_COORDINATES)s:* Enter the X and Y coordinates of the grid
cells directly. You can display an image of your grid to find the
locations of the centers of the cells, then enter the X and Y
position and cell coordinates for each of two cells.
""" % globals(),
)
self.manual_image = ImageSubscriber(
"Select the image to display when drawing",
"None",
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_MOUSE)s" to define
the grid)*
Specify the image you want to display when defining the grid. This
setting lets you choose the image to display in the grid definition user
interface.
""" % globals(),
)
self.first_spot_coordinates = Coordinates(
"Coordinates of the first cell",
(0, 0),
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
Enter the coordinates of the first cell on your grid. This setting
defines the location of the first of two cells in your grid. You should
enter the coordinates of the center of the cell. You can display an
image of your grid and use the pixel coordinate display to determine the
coordinates of the center of your cell.
""" % globals(),
)
self.first_spot_row = Integer(
"Row number of the first cell",
1,
minval=1,
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
Enter the row index for the first cell here. Rows are numbered starting
at the origin. For instance, if you chose "*%(NUM_TOP_LEFT)s*" as your
origin, well A01 will be row number 1 and H01 will be row number 8. If
you chose "*%(NUM_BOTTOM_LEFT)s*", A01 will be row number 8 and H01 will
be row number 12.
""" % globals(),
)
self.first_spot_col = Integer(
"Column number of the first cell",
1,
minval=1,
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
Enter the column index for the first cell here. Columns are numbered
starting at the origin. For instance, if you chose "*%(NUM_TOP_LEFT)s*"
as your origin, well A01 will be column number *1* and A12 will be
column number *12*. If you chose "*%(NUM_TOP_RIGHT)s*", A01 and A12 will
be *12* and *1*, respectively.
""" % globals(),
)
self.second_spot_coordinates = Coordinates(
"Coordinates of the second cell",
(0, 0),
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
This setting defines the location of the second of two cells in your
grid. You should enter the coordinates of the center of the cell. You
can display an image of your grid and use the pixel coordinate
display to determine the coordinates (X,Y) of the center of your cell.
""" % globals(),
)
self.second_spot_row = Integer(
"Row number of the second cell",
1,
minval=1,
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
Enter the row index for the second cell here. Rows are numbered starting
at the origin. For instance, if you chose "*%(NUM_TOP_LEFT)s*" as your
origin, well A01 will be row number 1 and H01 will be row number 8. If
you chose "*%(NUM_BOTTOM_LEFT)s*", A01 will be row number 8 and H01 will
be row number 12.
""" % globals(),
)
self.second_spot_col = Integer(
"Column number of the second cell",
1,
minval=1,
doc="""\
*(Used only if you selected "%(AM_MANUAL)s" and "%(MAN_COORDINATES)s" to
define the grid)*
Enter the column index for the second cell here. Columns are numbered
starting at the origin. For instance, if you chose "*%(NUM_TOP_LEFT)s*"
as your origin, well A01 will be column number 1 and A12 will be column
number 12. If you chose "*%(NUM_TOP_RIGHT)s*", A01 and A12 will be 12
and 1, respectively.
""" % globals(),
)
self.wants_image = Binary(
"Retain an image of the grid?",
False,
doc="""\
Select "*Yes*" to retain an image of the grid for use later in the
pipeline. This module can create an annotated image of the grid that can
be saved using the **SaveImages** module.
""" % globals(),
)
self.display_image_name = ImageSubscriber(
"Select the image on which to display the grid",
"Leave blank",
can_be_blank=True,
doc="""\
*(Used only if saving an image of the grid)*
Enter the name of the image that should be used as the background for
annotations (grid lines and grid indexes). This image will be used for
the figure and for the saved image.
""",
)
self.save_image_name = ImageName(
"Name the output image",
"Grid",
doc="""\
*(Used only if retaining an image of the grid for use later in the
pipeline)*
Enter the name you want to use for the output image. You can save this
image using the **SaveImages** module.
""",
)
self.failed_grid_choice = Choice(
"Use a previous grid if gridding fails?",
[FAIL_NO, FAIL_ANY_PREVIOUS, FAIL_FIRST],
doc="""\
If the gridding fails, this setting allows you to control how the module
responds to the error:
- *%(FAIL_NO)s:* The module will stop the pipeline if gridding fails.
- *%(FAIL_ANY_PREVIOUS)s:* The module will use the the most recent
successful gridding.
- *%(FAIL_FIRST)s:* The module will use the first gridding.
Note that the pipeline will stop in all cases if gridding fails on the
first image.
""" % globals(),
)
def create_settings(self):
"""Create the module settings
create_settings is called at the end of initialization.
"""
self.object = LabelSubscriber(
text="Select the object whose measurements will be displayed",
value="None",
doc=textwrap.dedent("""\
Choose the name of objects identified by some previous module (such as
**IdentifyPrimaryObjects** or **IdentifySecondaryObjects**) whose
measurements are to be displayed.
"""),
)
self.x_axis = Measurement(
text="Select the object measurement to plot",
object_fn=self.get_object,
value="None",
doc=
"Choose the object measurement made by a previous module to plot.",
)
self.bins = Integer(
text="Number of bins",
value=100,
minval=1,
maxval=1000,
doc=
"Enter the number of equally-spaced bins that you want used on the X-axis.",
)
self.xscale = Choice(
text="How should the X-axis be scaled?",
choices=["linear", "log"],
value=None,
doc=textwrap.dedent("""\
The measurement data can be scaled with either a **{LINEAR}** scale or
a **{LOG_NATURAL}** (natural log) 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.
""".format(
LINEAR="linear",
LOG_NATURAL="log",
)),
)
self.yscale = Choice(
text="How should the Y-axis be scaled?",
choices=["linear", "log"],
value=None,
doc=textwrap.dedent("""\
The Y-axis can be scaled either with either a **{LINEAR}** scale or a **{LOG_NATURAL}**
(natural log) 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.
""".format(
LINEAR="linear",
LOG_NATURAL="log",
)),
)
self.title = Text(
text="Enter a title for the plot, if desired",
value="",
doc=textwrap.dedent("""\
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.
"""),
)
self.wants_xbounds = Binary(
text="Specify min/max bounds for the X-axis?",
value=False,
doc=textwrap.dedent("""\
Select "**{YES}**" to specify minimum and maximum values for the plot on
the X-axis. This is helpful if an outlier bin skews the plot such that
the bins of interest are no longer visible.
""".format(YES="Yes")),
)
self.xbounds = FloatRange(
text="Minimum/maximum values for the X-axis",
doc="Set lower/upper limits for X-axis of the histogram.",
)
def create_settings(self):
self.x_source = 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 = LabelSubscriber(
"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 = 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 = 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 = LabelSubscriber(
"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 = 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 = 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 = 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 = 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 create_settings(self):
self.object_name = LabelSubscriber(
"Select the input objects",
"None",
doc="Select the objects that you want to expand or shrink.",
)
self.output_object_name = LabelName(
"Name the output objects",
"ShrunkenNuclei",
doc="Enter a name for the resulting objects.",
)
self.operation = Choice(
"Select the operation",
O_ALL,
doc="""\
Choose the operation that you want to perform:
- *{O_SHRINK_INF}:* Remove all pixels but one from filled objects.
Thin objects with holes to loops unless the “fill” option is checked.
Objects are never lost using this module (shrinking stops when an
object becomes a single pixel).
- *{O_EXPAND_INF}:* Expand objects, assigning every pixel in the
image to an object. Background pixels are assigned to the nearest
object.
- *{O_DIVIDE}:* Remove pixels from an object that are adjacent to
another object’s pixels unless doing so would change the object’s
Euler number (break an object in two, remove the object completely or
open a hole in an object).
- *{O_SHRINK}:* Remove pixels around the perimeter of an object unless
doing so would change the object’s Euler number (break the object in
two, remove the object completely or open a hole in the object). You
can specify the number of times perimeter pixels should be removed.
Processing stops automatically when there are no more pixels to
remove. Objects are never lost using this module (shrinking
stops when an object becomes a single pixel).
- *{O_EXPAND}:* Expand each object by adding background pixels
adjacent to the image. You can choose the number of times to expand.
Processing stops automatically if there are no more background
pixels.
- *{O_SKELETONIZE}:* Erode each object to its skeleton.
- *{O_SPUR}:* Remove or reduce the length of spurs in a skeletonized
image. The algorithm reduces spur size by the number of pixels
indicated in the setting *Number of pixels by which to expand or
shrink*.
""".format(
**{
"O_DIVIDE": O_DIVIDE,
"O_EXPAND": O_EXPAND,
"O_EXPAND_INF": O_EXPAND_INF,
"O_SHRINK": O_SHRINK,
"O_SHRINK_INF": O_SHRINK_INF,
"O_SKELETONIZE": O_SKELETONIZE,
"O_SPUR": O_SPUR,
}),
)
self.iterations = Integer(
"Number of pixels by which to expand or shrink",
1,
minval=1,
doc="""\
*(Used only if "{O_SHRINK}", "{O_EXPAND}", or "{O_SPUR}" is selected)*
Specify the number of pixels to add or remove from object borders.
""".format(**{
"O_EXPAND": O_EXPAND,
"O_SHRINK": O_SHRINK,
"O_SPUR": O_SPUR
}),
)
self.wants_fill_holes = Binary(
"Fill holes in objects so that all objects shrink to a single point?",
False,
doc="""\
*(Used only if one of the “Shrink” options selected)*
Select *{YES}* to ensure that each object will shrink to a single
point, by filling the holes in each object.
Select *{NO}* to preserve the Euler number. In this case, the shrink
algorithm preserves each object’s Euler number, which means that it will
erode an object with a hole to a ring in order to keep the hole. An
object with two holes will be shrunk to two rings connected by a line in
order to keep from breaking up the object or breaking the hole.
""".format(**{
"NO": "No",
"YES": "Yes"
}),
)
def create_settings(self):
"""Create the settings that control this module"""
self.object_name = LabelSubscriber(
"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 = LabelName(
"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 = 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 = LabelSubscriber(
"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 = ImageSubscriber(
"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 = 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 = 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 = 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 = 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(),
)
