def add_outline(self, can_remove=True):
group = cps.SettingsGroup()
if can_remove:
group.append("divider", cps.Divider(line=False))
group.append(
"outline_choice",
cps.Choice("Load outlines from an image or objects?",
[FROM_OBJECTS, FROM_IMAGES],
doc="""
This setting selects what source the outlines come from:
<ul>
<li><i>%(FROM_OBJECTS)s:</i> Create the image directly from the
objects. This option will improve the functionality of the
contrast options for this module's interactive display and will
save memory.</li>
<li><i>%(FROM_IMAGES)s:</i> Prior versions of <b>OverlayOutlines</b> would only
display outline images which were optional outputs of the identify
modules. For legacy pipelines or to continue using the outline
images instead of objects, choose this option.</li>
</ul>
""" % globals()))
group.append(
"objects_name",
cps.ObjectNameSubscriber(
"Select objects to display",
cps.NONE,
doc="""Choose the objects whose outlines you would like
to display."""))
group.append(
"outline_name",
cps.OutlineNameSubscriber("Select outlines to display",
cps.NONE,
doc="""
Choose outlines to display, from a previous <b>Identify</b>
module. Each of the <b>Identify</b> modules has a checkbox that
determines whether the outlines are saved. If you have checked this,
you were asked to supply a name for the outline; you
can then select that name here.
"""))
default_color = (COLOR_ORDER[len(self.outlines)]
if len(self.outlines) < len(COLOR_ORDER) else
COLOR_ORDER[0])
group.append("color", cps.Color("Select outline color", default_color))
if can_remove:
group.append(
"remover",
cps.RemoveSettingButton("", "Remove this outline",
self.outlines, group))
self.outlines.append(group)
def create_settings(self) -> None:
self.input_mask_name = cps.ObjectNameSubscriber(
text="Select the input mask", value=cps.NONE, doc="")
self.padding = cps.Integer(text="Enter padding size (px)",
value=20,
doc="")
self.output_mask_name = cps.ObjectNameProvider(
text="Name the output mask",
value="PaddedMask",
doc="Enter the name of the output mask",
)
self.custom = cps.Binary(text="Use custom settings?",
value="No",
doc="Use custom settings")
self.divider = cps.Divider(line=True)
self.image_name = cps.ImageNameSubscriber(
text="Select image to overlay on",
value=cps.LEAVE_BLANK,
doc="""\
Choose the image_name upon which a padded mask constructed from the input_mask is laid.
""",
can_be_blank=True,
)
self.input_mask_color = cps.Color(
text="Select the input mask color",
value="red",
doc="Select the input mask color",
)
self.output_mask_color = cps.Color(
text="Select the output mask color",
value="blue",
doc="Select the output mask color",
)
def create_settings(self) -> None:
module_explanation = "Creates a binary mask of the wedge."
self.set_notes([module_explanation])
self.wedge_mask_name = cps.ObjectNameProvider(
text="Name the wedge mask",
value="WedgeMask",
doc="Enter the name of the wedge mask.",
)
self.image_name = cps.ImageNameProvider(
text="Select image to overlay on",
value="None",
doc="""\
Choose the image_name upon which a wedge mask constructed from the given
parameters is laid. Can be either RGB or grayscale.
""",
)
self.divider = cps.Divider(line=True)
self.thickness = cps.Float(text="Enter thickness of wedge (um)",
value=400.0,
doc="")
self.span = cps.Float(text="Enter span of wedge (deg)",
value=90.0,
doc="")
self.radial_offset = cps.Float(
text="Enter radial offset",
value=0.0,
doc=
"Enter offset of the inner edge of wedge from well, in microns.",
)
self.angular_offset = cps.Float(
text="Enter angular offset",
value=0.0,
doc="""\
Enter offset of the wedge midline from well midline, in degrees, clockwise positive.
""",
)
self.mask_color = cps.Color(
text="Select wedge fill color",
value=DEFAULT_MASK_COLOR,
doc="""\
The wedge is outlined in this color. Only applies when the result of this
module is visualized.""",
)
def add_stack_channel_cb(self, can_remove=True):
group = cps.SettingsGroup()
default_color = DEFAULT_COLORS[len(self.stack_channels) %
len(DEFAULT_COLORS)]
group.append(
"image_name",
cps.ImageNameSubscriber(
"Image name",
cps.NONE,
doc="""\
*(Used only if "%(SCHEME_STACK)s" or "%(SCHEME_COMPOSITE)s" is chosen)*
Select the input image to add to the stacked image.
""" % globals(),
),
)
group.append(
"color",
cps.Color(
"Color",
default_color,
doc="""\
*(Used only if "%(SCHEME_COMPOSITE)s" is chosen)*
The color to be assigned to the above image.
""" % globals(),
),
)
group.append(
"weight",
cps.Float(
"Weight",
1.0,
minval=0.5 / 255,
doc="""\
*(Used only if "%(SCHEME_COMPOSITE)s" is chosen)*
The weighting of the above image relative to the others. The image’s
pixel values are multiplied by this weight before assigning the color.
""" % globals(),
),
)
if can_remove:
group.append(
"remover",
cps.RemoveSettingButton("", "Remove this image",
self.stack_channels, group),
)
self.stack_channels.append(group)
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.
""")
def create_settings(self):
self.orig_image_name = cps.ImageNameSubscriber(
"Select the input images", cps.NONE, doc="""
Select the images to display on the web page.""")
self.wants_thumbnails = cps.Binary(
"Use thumbnail images?", False, doc="""
Select <i>%(YES)s</i> to display thumbnail images (small versions of the
images) on the web page that link to the full images. <br>
Select <i>%(NO)s</i> to display the full image directly on the web page.
<p>If you are going to use thumbnails, you will need to load
them using the <b>Input</b> modules; you can also run a separate
pipeline prior to this one to create thumbnails from your originals
using the <b>Resize</b> and <b>SaveImages</b> modules. For some high-content
screening systems, thumbnail files are automatically created and have
the text "thumb" in the name.</p>""" % globals())
self.thumbnail_image_name = cps.ImageNameSubscriber(
"Select the thumbnail images", cps.NONE, doc="""
<i>(Used only if using thumbnails)</i><br>
Select the name of the images to use for thumbnails.""")
self.web_page_file_name = cps.Text(
"Webpage file name", "images1",
metadata=True, doc="""
Enter the desired file name for the web page. <b>CreateWebPage</b>
will add the .html extension if no extension is specified.
If you have metadata associated with your images, you can name the
file using metadata tags. %(USING_METADATA_TAGS_REF)s<br>
For instance, if you have metadata tags named "Plate" and
"Well", you can create separate per-plate, per-well web pages based on
your metadata by inserting the tags "Plate_Well" to specify the
name. %(USING_METADATA_HELP_REF)s.""" % globals())
self.directory_choice = CWPDirectoryPath(
"Select the folder for the .html file",
dir_choices=[
DIR_SAME, DIR_ABOVE, ABSOLUTE_FOLDER_NAME,
DEFAULT_INPUT_FOLDER_NAME, DEFAULT_OUTPUT_FOLDER_NAME,
DEFAULT_INPUT_SUBFOLDER_NAME, DEFAULT_OUTPUT_SUBFOLDER_NAME],
doc="""
This setting determines how <b>CreateWebPage</b> selects the
folder for the .html file(s) it creates.
<ul>
<li><i>%(DIR_SAME)s</i>: Place the .html file(s) in the same folder as
the files.</li>
<li><i>%(DIR_ABOVE)s</i>: Place the .html file(s) in the
image files' parent folder.</li>
<li><i>%(ABSOLUTE_FOLDER_NAME)s</i>: Places the .html file(s) in
a folder of your choosing. <b>CreateWebPage</b> will use absolute
references for your image URLs if you choose this option.</li>
<li><i>%(DEFAULT_INPUT_FOLDER_NAME)s</i>: Places the .html file(s)
in the default input folder.</li>
<li><i>%(DEFAULT_OUTPUT_FOLDER_NAME)s</i>: Places the .html file(s)
in the default output folder.</li>
<li><i>%(DEFAULT_INPUT_SUBFOLDER_NAME)s</i>: Places the .html file(s)
in a subfolder of the default input folder. You will be prompted
for the subfolder name after making this choice</li>
<li><i>%(DEFAULT_OUTPUT_SUBFOLDER_NAME)s</i>: Places the .html file(s)
in a subfolder of the default input folder. You will be prompted
for the subfolder name after making this choice</li>
</ul>""" % globals())
self.title = cps.Text(
"Webpage title", "Image", metadata=True, doc="""
This is the title that appears at the top of the browser
window. If you have metadata associated with your images, you can name the
file using metadata tags. %(USING_METADATA_TAGS_REF)sFor instance, if you
have a metadata tag named "Plate", you can type "Plate: " and then insert
the metadata tag "Plate" to display the plate metadata item. %(USING_METADATA_HELP_REF)s."""
% globals())
self.background_color = cps.Color(
"Webpage background color", "White", doc="""
This setting controls the background color for the web page.""")
self.columns = cps.Integer(
"Number of columns", 1, minval=1, doc="""
This setting determines how many images are displayed
in each row.""")
self.table_border_width = cps.Integer(
"Table border width", 1, minval=0, doc="""
The table border width determines the width of the border
around the entire grid of displayed images (i.e., the "table" of images)
and is measured in pixels. This value can be
set to zero, in which case you will not see the table border.""")
self.table_border_color = cps.Color(
"Table border color", "White")
self.image_spacing = cps.Integer(
"Image spacing", 1, minval=0, doc="""
The spacing between images ("table cells"), in pixels.""")
self.image_border_width = cps.Integer(
"Image border width", 1, minval=0, doc="""
The image border width determines the width of
the border around each image and is measured in pixels.
This value can be set to zero, in which case you will not see the
image border.""")
self.create_new_window = cps.Choice(
"Open new window when viewing full image?",
[OPEN_ONCE, OPEN_EACH, OPEN_NO], doc="""
This controls the behavior of the thumbnail links.
<ul>
<li><i>%(OPEN_ONCE)s:</i> Your browser will open a new window
when you click on the first thumbnail and will display subsequent
images in the newly opened window. </li>
<li><i>%(OPEN_EACH)s:</i> The browser will open a new window each time
you click on a link.</li>
<li><i>%(OPEN_NO)s:</i> The browser will reuse the current window
to display the image</li>
</ul>""" % globals())
self.wants_zip_file = cps.Binary(
"Make a ZIP file containing the full-size images?", False, doc="""
ZIP files are a common archive and data compression file format, making
it convenient to download all of the images represented on the web page with a single click.
Select <i>%(YES)s</i> to create a ZIP file that contains all your images,
compressed to reduce file size.""" % globals())
self.zipfile_name = cps.Text(
"Enter the ZIP file name", "Images.zip",
metadata=True, doc="""
<i>(Used only if creating a ZIP file)</i><br>
Specify the name for the ZIP file.""")
