def add_heatmap(self):
group = cps.SettingsGroup()
if len(self.heatmaps) > 0:
group.append("divider", cps.Divider(line=False))
group.append("image_name", MORDImageNameSubscriber(
"Image", doc="""
The heatmap will be displayed with measurements taken using this image.
The setting will let you choose from among the images you have
specified in "Select image to measure".
"""))
group.image_name.set_module(self)
group.append("object_name", MORDObjectNameSubscriber(
"Objects to display", doc="""
The objects to display in the heatmap. You can select any of the
objects chosen in "Select objects to measure".
"""))
group.object_name.set_module(self)
group.append("bin_count", cps.Choice(
"Number of bins", self.get_bin_count_choices(),
choices_fn=self.get_bin_count_choices))
def get_number_of_bins(module=self, group=group):
if len(module.bin_counts) == 1:
return module.bin_counts[0].bin_count.value
else:
return int(group.bin_count.value)
group.get_number_of_bins = get_number_of_bins
group.append("measurement", cps.Choice(
"Measurement", MEASUREMENT_CHOICES,
doc="""The measurement to display."""))
group.append("colormap", cps.Colormap(
"Color map",
doc="""
The color map setting chooses the color palette that will be
used to render the different values for your measurement. If you
choose "gray", the image will label each of the bins with the
actual image measurement.
"""))
group.append("wants_to_save_display", cps.Binary(
"Save display as image?", False,
doc="""This setting allows you to save the heatmap display as
an image that can be output using the <b>SaveImages</b> module.
Choose <i>%(YES)s</i> to save the display or <i>%(NO)s</i> if the
display is not needed.""" % globals()))
group.append("display_name", cps.ImageNameProvider(
"Output image name", "Heatmap",
doc="""
<i>(Only used if "Save display as image?" is "%(YES)s")</i><br>
This setting names the heatmap image so that the name you enter
here can be selected in a later <b>SaveImages</b> or other module.
""" % globals()))
group.append("remover", cps.RemoveSettingButton(
"", "Remove this heatmap display", self.heatmaps, group))
self.heatmaps.append(group)
def create_settings(self):
self.object_name = cps.ObjectNameSubscriber("Select the input objects",
cps.NONE,
doc="""
Choose the name of the objects you want to convert to an image.""")
self.image_name = cps.ImageNameProvider("Name the output image",
"CellImage",
doc="""
Enter the name of the resulting image.""")
self.image_mode = cps.Choice("Select the color format",
IM_ALL,
doc="""
Select which colors the resulting image should use. You have the following
options:
<ul>
<li><i>%(IM_COLOR)s:</i> Allows you to choose a colormap that will
produce jumbled colors for your objects. </li>
<li><i>%(IM_BINARY)s:</i> All object pixels will be assigned 1 and all
background pixels will be assigned 0, creating a binary image.</li>
<li><i>%(IM_GRAYSCALE)s:</i> Gives each object
a graylevel pixel intensity value corresponding to its number (also
called label), so it usually results in objects on the left side of the
image being very dark, progressing toward white on the right side of
the image. </li>
<li><i>%(IM_UINT16)s:</i> Assigns each object a different number,
from 1 to 65535 (the numbers that you can put in
a 16-bit integer) and numbers all pixels in each
object with the object's number. This format can
be written out as a .mat or .tiff file if you
want to process the label matrix image using
another program.</li>
</ul>
You can choose <i>%(IM_COLOR)s</i> with a <i>Gray</i> colormap to produce
jumbled gray objects.""" % globals())
self.colormap = cps.Colormap("Select the colormap",
doc="""
<i>(Used only if "<i>%(IM_COLOR)s</i>" output image selected)</i><br>
Choose the colormap to be used, which affects how the objects are colored.
You can look up your default colormap under <i>File > Preferences</i>.
""" % globals())
def create_settings(self):
self.object_name = cps.ObjectNameSubscriber(
'Select objects to measure',
cps.NONE,
doc="""
Select the objects whose neighbors you want to measure.""")
self.neighbors_name = cps.ObjectNameSubscriber(
'Select neighboring objects to measure',
cps.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 = cps.Choice('Method to determine neighbors',
D_ALL,
D_EXPAND,
doc="""
There are several methods by which to determine whether objects are neighbors:
<ul>
<li><i>%(D_ADJACENT)s:</i> In this mode, two objects must have adjacent
boundary pixels to be neighbors. </li>
<li><i>%(D_EXPAND)s:</i> 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.</li>
<li><i>%(D_WITHIN)s:</i> Each object is expanded by
the number of pixels you specify. Two objects are
neighbors if they have adjacent pixels after expansion. </li>
</ul>
<p>For <i>%(D_ADJACENT)s</i> and <i>%(D_EXPAND)s</i>, the
<i>%(M_PERCENT_TOUCHING)s</i> measurement is the percentage of pixels on the boundary
of an object that touch adjacent objects. For <i>%(D_WITHIN)s</i>,
two objects are touching if any of their boundary
pixels are adjacent after expansion and <i>%(M_PERCENT_TOUCHING)s</i> measures the
percentage of boundary pixels of an <i>expanded</i> object that
touch adjacent objects.</p>""" % globals())
self.distance = cps.Integer('Neighbor distance',
5,
1,
doc="""
<i>(Used only when "%(D_WITHIN)s" is selected)</i> <br>
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 = cps.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 <b>SaveImages</b>
module to save this image to a file.""")
self.count_image_name = cps.ImageNameProvider('Name the output image',
'ObjectNeighborCount',
doc="""
<i>(Used only if the image of objects colored by numbers of neighbors
is to be retained for later use in the pipeline)</i> <br>
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 = cps.Colormap('Select colormap',
doc="""
<i>(Used only if the image of objects colored by numbers of neighbors
is to be retained for later use in the pipeline)</i> <br>
Select the colormap to use to color the neighbor number image. All available colormaps can be seen
<a href="http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps">here</a>."""
)
self.wants_percent_touching_image = cps.Binary(
'Retain the image of objects colored by percent of touching pixels?',
False,
doc="""
Select <i>%(YES)s</i> 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 <b>SaveImages</b> module to save this image to a file."""
% globals())
self.touching_image_name = cps.ImageNameProvider(
'Name the output image',
'PercentTouching',
doc="""
<i>(Used only if the image of objects colored by percent touching
is to be retained for later use in the pipeline)</i> <br>
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 = cps.Colormap('Select a colormap',
doc="""
<i>(Used only if the image of objects colored by percent touching
is to be retained for later use in the pipeline)</i> <br>
Select the colormap to use to color the percent touching image. All available colormaps can be seen
<a href="http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps">here</a>."""
)
def create_settings(self):
self.object_name = cps.ObjectNameSubscriber(
'Select objects to measure',
cps.NONE,
doc="""\
Select the objects whose neighbors you want to measure.""")
self.neighbors_name = cps.ObjectNameSubscriber(
'Select neighboring objects to measure',
cps.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 = cps.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 = cps.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 = cps.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 = cps.ImageNameProvider('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 = cps.Colormap('Select colormap',
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 = cps.Binary(
'Retain the image of objects colored by percent of touching pixels?',
False,
doc="""\
Select *%(YES)s* 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 = cps.ImageNameProvider(
'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 = cps.Colormap('Select colormap',
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""")
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.settings.ImageNameSubscriber(...)
# Ask the user for the name of the output image
self.output_image = cellprofiler.settings.ImageNameProvider(...)
# Ask the user for a parameter
self.smoothing_size = cellprofiler.settings.Float(...)
"""
self.objects_or_image = cps.Choice(
"Display object or image measurements?", [OI_OBJECTS, OI_IMAGE],
doc="""\
- *%(OI_OBJECTS)s* displays measurements made on objects.
- *%(OI_IMAGE)s* displays a single measurement made on an image.
""" % globals())
self.objects_name = cps.ObjectNameSubscriber(
"Select the input objects",
cps.NONE,
doc="""\
*(Used only when displaying object measurements)*
Choose the name of objects identified by some previous module (such as
**IdentifyPrimaryObjects** or **IdentifySecondaryObjects**).
""")
def object_fn():
if self.objects_or_image == OI_OBJECTS:
return self.objects_name.value
else:
return cpmeas.IMAGE
self.measurement = cps.Measurement("Measurement to display",
object_fn,
doc="""\
Choose the measurement to display. This will be a measurement made by
some previous module on either the whole image (if displaying a single
image measurement) or on the objects you selected.
""")
self.wants_image = cps.Binary("Display background image?",
True,
doc="""\
Choose whether or not to display the measurements on
a background image. Usually, you will want to see the image
context for the measurements, but it may be useful to save
just the overlay of the text measurements and composite the
overlay image and the original image later. Choose "Yes" to
display the measurements on top of a background image or "No"
to display the measurements on a black background.""")
self.image_name = cps.ImageNameSubscriber(
"Select the image on which to display the measurements",
cps.NONE,
doc="""\
Choose the image to be displayed behind the measurements.
This can be any image created or loaded by a previous module.
If you have chosen not to display the background image, the image
will only be used to determine the dimensions of the displayed image.""")
self.color_or_text = cps.Choice("Display mode", [CT_TEXT, CT_COLOR],
doc="""\
*(Used only when displaying object measurements)*
Choose how to display the measurement information. If you choose
%(CT_TEXT)s, **DisplayDataOnImage** will display the numeric value on
top of each object. If you choose %(CT_COLOR)s, **DisplayDataOnImage**
will convert the image to grayscale, if necessary, and display the
portion of the image within each object using a hue that indicates the
measurement value relative to the other objects in the set using the
default color map.
""" % globals())
self.colormap = cps.Colormap("Color map",
doc="""\
*(Used only when displaying object measurements)*
This is the color map used as the color gradient for coloring the
objects by their measurement values. See `this page`_ for pictures
of the available colormaps.
.. _this page: http://matplotlib.org/users/colormaps.html
""")
self.text_color = cps.Color(
"Text color",
"red",
doc=
"""This is the color that will be used when displaying the text."""
)
self.display_image = cps.ImageNameProvider(
"Name the output image that has the measurements displayed",
"DisplayImage",
doc="""\
The name that will be given to the image with the measurements
superimposed. You can use this name to refer to the image in subsequent
modules (such as **SaveImages**).
""")
self.font_size = cps.Integer(
"Font size (points)",
10,
minval=1,
doc="""Set the font size of the letters to be displayed.""")
self.decimals = cps.Integer(
"Number of decimals",
2,
minval=0,
doc=
"""Set how many decimals to be displayed, for example 2 decimals for 0.01; 3 decimals for 0.001."""
)
self.saved_image_contents = cps.Choice("Image elements to save",
[E_IMAGE, E_FIGURE, E_AXES],
doc="""\
This setting controls the level of annotation on the image:
- *%(E_IMAGE)s:* Saves the image with the overlaid measurement
annotations.
- *%(E_AXES)s:* Adds axes with tick marks and image coordinates.
- *%(E_FIGURE)s:* Adds a title and other decorations.
""" % globals())
self.offset = cps.Integer("Annotation offset (in pixels)",
0,
doc="""\
Add a pixel offset to the measurement. Normally, the text is
placed at the object (or image) center, which can obscure relevant features of
the object. This setting adds a specified offset to the text, in a random
direction.""")
self.color_map_scale_choice = cps.Choice(
"Color map scale", [CMS_USE_MEASUREMENT_RANGE, CMS_MANUAL],
doc="""\
*(Used only when displaying object measurements as a colormap)*
**DisplayDataOnImage** assigns a color to each object’s measurement
value from a colormap when in colormap-mode, mapping the value to a
color along the colormap’s continuum. This mapping has implicit upper
and lower bounds to its range which are the extremes of the colormap.
This setting determines whether the extremes are the minimum and
maximum values of the measurement from among the objects in the
current image or manually-entered extremes.
- *%(CMS_USE_MEASUREMENT_RANGE)s:* Use the full range of colors to
get the maximum contrast within the image.
- *%(CMS_MANUAL)s:* Manually set the upper and lower bounds so that
images with different maxima and minima can be compared by a uniform
color mapping.
""" % globals())
self.color_map_scale = cps.FloatRange("Color map range",
value=(0.0, 1.0),
doc="""\
*(Used only when setting a manual colormap range)*
This setting determines the lower and upper bounds of the values for the
color map.
""")