def create_settings(self):
super(HistogramEqualization, self).create_settings()
self.nbins = cellprofiler_core.setting.text.Integer(
u"Bins",
value=256,
minval=0,
doc="Number of bins for image histogram.")
self.kernel_size = cellprofiler_core.setting.text.Integer(
u"Kernel Size",
value=256,
minval=1,
doc=
"""The image is partitioned into tiles with dimensions specified by the kernel size. Choose a kernel
size that will fit at least one object of interest.
""")
self.mask = ImageSubscriber(u"Mask",
can_be_blank=True,
doc="""
Optional. Mask image must be the same size as "Input". Only unmasked points of the "Input" image are used
to compute the equalization, which is applied to the entire "Input" image.
""")
self.local = cellprofiler_core.setting.Binary(u"Local", False)
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):
self.image_name = ImageSubscriber(
"Select the input image",
"None",
doc="""\
Select the image that you want to perform a morphological operation on.
A grayscale image can be converted to binary using the **Threshold**
module. Objects can be converted to binary using the **ConvertToImage**
module.""",
)
self.output_image_name = ImageName(
"Name the output image",
"MorphBlue",
doc="""Enter the name for the output image. It will be of the same type as the input image.""",
)
self.add_button = DoSomething(
"",
"Add another operation",
self.add_function,
doc="""\
Press this button to add an operation that will be applied to the
image resulting from the previous operation(s). The module repeats
the previous operation the number of times you select before applying
the operation added by this button.""",
)
self.functions = []
self.add_function(can_remove=False)
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 add_image_in(self, can_delete=True):
"""Add an image to the image_groups collection
can_delete - set this to False to keep from showing the "remove"
button for images that must be present.
"""
group = SettingsGroup()
if can_delete:
group.append("divider", Divider(line=False))
group.append(
"image_name",
ImageSubscriber('Select an image to send to your macro',
"None",
doc="Select an image to send to your macro. "))
group.append(
"output_filename",
Text(
"What should this image temporarily saved as?",
"None.tiff",
doc=
'Enter the filename of the image to be used by the macro. This should be set to the name expected '
'by the macro file.'),
)
if len(self.image_groups_in
) == 0: # Insert space between 1st two images for aesthetics
group.append("extra_divider", Divider(line=False))
if can_delete:
group.append(
"remover",
RemoveSettingButton("", "Remove this image",
self.image_groups_in, group))
self.image_groups_in.append(group)
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):
self.outputs = []
self.stain_count = HiddenCount(self.outputs, "Stain count")
self.input_image_name = ImageSubscriber(
"Select the input color image",
"None",
doc="""\
Choose the name of the histologically stained color image
loaded or created by some prior module.""",
)
self.add_image(False)
self.add_image_button = DoSomething(
"",
"Add another stain",
self.add_image,
doc="""\
Press this button to add another stain to the list.
You will be able to name the image produced and to either pick
the stain from a list of pre-calibrated stains or to enter
custom values for the stain's red, green and blue absorbance.
""",
)
def add_image(self, can_remove=True):
group = SettingsGroup()
if can_remove:
group.append("divider", Divider(line=False))
group.append(
"input_image_name",
ImageSubscriber(
"Select the additional image?",
"None",
doc="""\
What is the name of the additional image to resize? This image will be
resized with the same settings as the first image.""",
),
)
group.append(
"output_image_name",
ImageName(
"Name the output image",
"ResizedBlue",
doc="What is the name of the additional resized image?",
),
)
if can_remove:
group.append(
"remover",
RemoveSettingButton(
"", "Remove above image", self.additional_images, group
),
)
self.additional_images.append(group)
def create_settings(self):
super(IdentifyNucleus, self).create_settings()
self.mask_name = ImageSubscriber("Mask", can_be_blank=True, doc="")
self.model_pathname = Pathname("Model", doc="")
self.weights_pathname = Pathname("Weights", doc="")
def create_settings(self):
self.skeleton_name = ImageSubscriber(
"Select an image to measure",
doc="""\
Select the morphological skeleton image you wish to measure.
You can create a morphological skeleton with the
**MorphologicalSkeleton** module from the *Advanced* category.
""",
)
def create_settings(self):
super(EdgeDetection, self).create_settings()
self.mask = ImageSubscriber(u"Mask",
can_be_blank=True,
doc="""
Optional. A binary image the same shape as "Input". Limit application of the edge filter to unmasked
regions of "Input".
""")
def create_settings(self):
super(ResizeObjects, self).create_settings()
self.method = Choice(
"Method",
["Dimensions", "Factor", "Match Image"],
doc="""\
The following options are available:
- *Dimensions:* Enter the new height and width of the resized objects.
- *Factor:* Enter a single value which specifies the scaling.""",
value="Factor",
)
self.factor = Float(
"Factor",
0.25,
minval=0,
doc="""\
*(Used only if resizing by "Factor")*
Numbers less than 1 will shrink the objects; numbers greater than 1 will
enlarge the objects.""",
)
self.width = Integer(
"Width",
100,
minval=1,
doc="""\
*(Used only if resizing by "Dimensions")*
Enter the desired width of the final objects, in pixels.""",
)
self.height = Integer(
"Height",
100,
minval=1,
doc="""\
*(Used only if resizing by "Dimensions")*
Enter the desired height of the final objects, in pixels.""",
)
self.specific_image = ImageSubscriber(
"Select the image with the desired dimensions",
"None",
doc="""\
*(Used only if resizing by specifying desired final dimensions using an image)*
The input object set will be resized to the dimensions of the specified image.""",
)
def create_settings(self):
self.skeleton_name = ImageSubscriber(
"Select an image to measure"
)
self.radius = Integer(
"Radius"
)
self.step = Integer(
"Step"
)
def add_stack_channel_cb(self, can_remove=True):
group = SettingsGroup()
default_color = DEFAULT_COLORS[len(self.stack_channels) % len(DEFAULT_COLORS)]
group.append(
"image_name",
ImageSubscriber(
"Image name",
"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",
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",
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",
RemoveSettingButton(
"", "Remove this image", self.stack_channels, group
),
)
self.stack_channels.append(group)
def convert_java_type_to_setting(param_name, param_type, param_class):
"""
Helper method to convert ImageJ/Java class parameter types to CellProfiler settings
Parameters
----------
param_name : str, required
The name of the parameter
param_type : str, required
The Java class name describing the parameter type
param_class: str, required
One of {input_class} or {output_class}, based on the parameter use
Returns
---------
A new Setting of a type appropriate for param_type, named with param_name. Or None if no valid conversion exists.
"""
type_string = param_type.split()[1]
img_strings = ("ij.ImagePlus", "net.imagej.Dataset", "net.imagej.ImgPlus")
if INPUT_CLASS == param_class:
param_label = param_name
if type_string == "java.lang.String":
return Alphanumeric(param_label, "")
if type_string == "java.lang.Character":
return Character(param_label, "")
elif type_string == "java.lang.Integer":
return Integer(param_label, 0, minval=-2 ** 31, maxval=((2 ** 31) - 1))
elif type_string == "java.lang.Long":
return Integer(param_label, 0, minval=-2 ** 63, maxval=((2 ** 63) - 1))
elif type_string == "java.lang.Short":
return Integer(param_label, 0, minval=-32768, maxval=32767)
elif type_string == "java.lang.Byte":
return Integer(param_label, 0, minval=-128, maxval=127)
elif type_string == "java.lang.Boolean":
return Boolean(param_label, 0)
elif type_string == "java.lang.Float":
return Float(param_label, minval=-2 ** 31, maxval=((2 ** 31) - 1))
elif type_string == "java.lang.Double":
return Float(param_label, minval=-2 ** 63, maxval=((2 ** 63) - 1))
elif type_string == "java.io.File":
return Filename(param_label, "")
elif bool((img_string for img_string in img_strings if type_string == img_string)):
return ImageSubscriber(param_label)
elif OUTPUT_CLASS == param_class:
if bool((img_string for img_string in img_strings if type_string == img_string)):
return ImageName("[OUTPUT, " + type_string + "] " + param_name, param_name, doc=
"""
You may use this setting to rename the indicated output variable, if desired.
"""
)
return None
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 create_settings(self):
self.synapsin_image = ImageSubscriber(
"Select the synapsin image", "None", doc="""\
Select the image of the synapsin-1 channel.""")
self.PSD95_image = ImageSubscriber(
"Select the PSD95 image", "None", doc="""\
Select the image of the PSD95 channel.""")
self.vGlut_image = ImageSubscriber(
"Select the vGlut image", "None", doc="""\
Select the image of the vGlut channel.""")
self.prediction_image_name = ImageName(
"Output image name",
"SynapsePrediction",
doc="""\
Enter the name to give the output prediction image created by this module.
""")
self.t7_name = Pathname(
"Trained network location",
doc="Specify the location of the trained network."
)
def create_settings(self):
self.input_image_name = ImageSubscriber(
"Image", doc="Select the image you want to use.")
self.template_name = Pathname(
"Template",
doc=
"Specify the location of the cropped image you want to use as a template.",
)
self.output_image_name = ImageName(
"Output",
doc=
"Enter the name you want to call the image produced by this module.",
)
def create_settings(self):
self.image_name = ImageSubscriber(
"Select the input image",
"None",
doc=
"""Choose the name of the image to display in the object selection user interface.""",
)
self.objects_name = LabelName(
"Name the objects to be identified",
"Cells",
doc="""\
What do you want to call the objects that you identify using this module? You can use this name to
refer to your objects in subsequent modules.""",
)
def add_image_cb(self, can_remove = True):
'''Add an image to the image_groups collection
can_delete - set this to False to keep from showing the "remove"
button for images that must be present.
'''
group = cps.SettingsGroup()
if can_remove:
group.append("divider", cps.Divider(line=False))
group.append('image_name',
ImageSubscriber("Select an image to measure","None",
doc="""
What did you call the grayscale images whose texture you want to measure?"""))
if can_remove:
group.append("remover", cps.do_something.RemoveSettingButton("", "Remove this image", self.image_groups, group))
self.image_groups.append(group)
def add_image(self, can_delete=True):
group = cps.SettingsGroup()
self.images_to_export.append(group)
group.append(
"image_name",
ImageSubscriber("Image name",
value="DNA",
doc="""
This setting lets you choose the images you want to export.
<b>ExportToCellH5</b> will write the image
to your CellH5 file so that it can be used by other
applications that support the format.
"""))
group.append(
"remover",
cps.do_something.RemoveSettingButton("Remove the image above",
"Remove",
self.objects_to_export,
group))
def add_image(self, can_remove=True):
"""Add an image + associated questions and buttons"""
group = SettingsGroup()
if can_remove:
group.append("divider", Divider(line=True))
group.append(
"input_image_name",
ImageSubscriber(
"Select an additional image to tile",
"None",
doc="""Select an additional image to tile?""",
),
)
if can_remove:
group.append(
"remover",
RemoveSettingButton("", "Remove above image",
self.additional_images, group),
)
self.additional_images.append(group)
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 create_settings(self):
self.scheme_choice = Choice(
"Select a color scheme",
[SCHEME_RGB, SCHEME_CMYK, SCHEME_STACK, SCHEME_COMPOSITE],
doc="""\
This module can use one of two color schemes to combine images:
- *%(SCHEME_RGB)s*: Each input image determines the intensity of one
of the color channels: red, green, and blue.
- *%(SCHEME_CMYK)s*: Three of the input images are combined to
determine the colors (cyan, magenta, and yellow) and a fourth is used
only for brightness. The cyan image adds equally to the green and
blue intensities. The magenta image adds equally to the red and blue
intensities. The yellow image adds equally to the red and green
intensities.
- *%(SCHEME_STACK)s*: The channels are stacked in the order listed,
from top to bottom. An arbitrary number of channels is allowed.
For example, you could create a 5-channel image by providing
5 grayscale images. The first grayscale image you provide will fill
the first channel, the second grayscale image you provide will fill
the second channel, and so on.
- *%(SCHEME_COMPOSITE)s*: A color is assigned to each grayscale image.
Each grayscale image is converted to color by multiplying the
intensity by the color and the resulting color images are added
together. An arbitrary number of channels can be composited into a
single color image.
"""
% globals(),
)
self.wants_rescale = Binary(
"Rescale intensity",
True,
doc="""\
Choose whether to rescale each channel individually to
the range of 0-1. This prevents clipping of channels with intensity
above 1 and can help to balance the brightness of the different channels.
This option also ensures that channels occupy the full intensity range
available, which is useful for displaying images in other software.
This rescaling is applied before any multiplication factors set in this
module's options. Using a multiplication factor >1 would therefore result
in clipping."""
)
# # # # # # # # # # # # # # # #
#
# RGB settings
#
# # # # # # # # # # # # # # # #
self.red_image_name = ImageSubscriber(
"Select the image to be colored red",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Select the input image to be displayed in red.
"""
% globals(),
)
self.green_image_name = ImageSubscriber(
"Select the image to be colored green",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Select the input image to be displayed in green.
"""
% globals(),
)
self.blue_image_name = ImageSubscriber(
"Select the image to be colored blue",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Select the input image to be displayed in blue.
"""
% globals(),
)
self.rgb_image_name = ImageName(
"Name the output image",
"ColorImage",
doc="""Enter a name for the resulting image.""",
)
self.red_adjustment_factor = Float(
"Relative weight for the red image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Enter the relative weight for the red image. If all relative weights are
equal, all three colors contribute equally in the final image. To weight
colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
self.green_adjustment_factor = Float(
"Relative weight for the green image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Enter the relative weight for the green image. If all relative weights
are equal, all three colors contribute equally in the final image. To
weight colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
self.blue_adjustment_factor = Float(
"Relative weight for the blue image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_RGB)s" is selected as the color scheme)*
Enter the relative weight for the blue image. If all relative weights
are equal, all three colors contribute equally in the final image. To
weight colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
# # # # # # # # # # # # # #
#
# CYMK settings
#
# # # # # # # # # # # # # #
self.cyan_image_name = ImageSubscriber(
"Select the image to be colored cyan",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Select the input image to be displayed in cyan.
"""
% globals(),
)
self.magenta_image_name = ImageSubscriber(
"Select the image to be colored magenta",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Select the input image to be displayed in magenta.
"""
% globals(),
)
self.yellow_image_name = ImageSubscriber(
"Select the image to be colored yellow",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Select the input image to be displayed in yellow.
"""
% globals(),
)
self.gray_image_name = ImageSubscriber(
"Select the image that determines brightness",
can_be_blank=True,
blank_text=LEAVE_THIS_BLACK,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Select the input image that will determine each pixel's brightness.
"""
% globals(),
)
self.cyan_adjustment_factor = Float(
"Relative weight for the cyan image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Enter the relative weight for the cyan image. If all relative weights
are equal, all colors contribute equally in the final image. To weight
colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
self.magenta_adjustment_factor = Float(
"Relative weight for the magenta image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Enter the relative weight for the magenta image. If all relative weights
are equal, all colors contribute equally in the final image. To weight
colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
self.yellow_adjustment_factor = Float(
"Relative weight for the yellow image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Enter the relative weight for the yellow image. If all relative weights
are equal, all colors contribute equally in the final image. To weight
colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
self.gray_adjustment_factor = Float(
"Relative weight for the brightness image",
value=1,
minval=0,
doc="""\
*(Used only if "%(SCHEME_CMYK)s" is selected as the color scheme)*
Enter the relative weight for the brightness image. If all relative
weights are equal, all colors contribute equally in the final image. To
weight colors relative to each other, increase or decrease the relative
weights.
"""
% globals(),
)
# # # # # # # # # # # # # #
#
# Stack settings
#
# # # # # # # # # # # # # #
self.stack_channels = []
self.stack_channel_count = HiddenCount(self.stack_channels)
self.add_stack_channel_cb(can_remove=False)
self.add_stack_channel = DoSomething(
"Add another channel",
"Add another channel",
self.add_stack_channel_cb,
doc="""\
Press this button to add another image to the stack.
""",
)
def add_image(self, removable=True):
# The text for these settings will be replaced in renumber_settings()
group = SettingsGroup()
group.removable = removable
group.append(
"image_or_measurement",
Choice(
"Image or measurement?",
[IM_IMAGE, IM_MEASUREMENT],
doc="""\
You can perform math operations using two images or you can use a
measurement for one of the operands. For instance, to divide the
intensity of one image by another, choose *%(IM_IMAGE)s* for both and
pick the respective images. To divide the intensity of an image by its
median intensity, use **MeasureImageIntensity** prior to this module to
calculate the median intensity, then select *%(IM_MEASUREMENT)s* and
use the median intensity measurement as the denominator.
""" % globals(),
),
)
group.append(
"image_name",
ImageSubscriber(
"Select the image",
"None",
doc="""\
Select the image that you want to use for this operation.""",
),
)
group.append(
"measurement",
Measurement(
"Measurement",
lambda: "Image",
"",
doc="""\
Select a measurement made on the image. The value of the
measurement is used for the operand for all of the pixels of the
other operand's image.""",
),
)
group.append(
"factor",
Float(
"Multiply the image by",
1,
doc="""\
Enter the number that you would like to multiply the above image by. This multiplication
is applied before other operations.""",
),
)
if removable:
group.append(
"remover",
RemoveSettingButton("", "Remove this image", self.images,
group),
)
group.append("divider", Divider())
self.images.append(group)
def create_settings(self):
super(DeclumpObjects, self).create_settings()
self.declump_method = cellprofiler_core.setting.choice.Choice(
text="Declump method",
choices=[O_SHAPE, O_INTENSITY],
value=O_SHAPE,
doc="""\
This setting allows you to choose the method that is used to draw the
line between segmented objects.
- *{O_SHAPE}:* Dividing lines between clumped objects are based on
the shape of the clump. For example, when a clump contains two
objects, the dividing line will be placed where indentations occur
between the two objects. The intensity of the original image is
not necessary in this case.
**Technical description:** The distance transform of the segmentation
is used to identify local maxima as seeds (i.e. the centers of the
individual objects), and the seeds are then used on the inverse of
that distance transform to determine new segmentations via watershed.
- *{O_INTENSITY}:* Dividing lines between clumped objects are determined
based on the intensity of the original image. This works best if the
dividing line between objects is dimmer than the objects themselves.
**Technical description:** The distance transform of the segmentation
is used to identify local maxima as seeds (i.e. the centers of the
individual objects). Those seeds are then used as markers for a
watershed on the inverted original intensity image.
""".format(**{
"O_SHAPE": O_SHAPE,
"O_INTENSITY": O_INTENSITY
})
)
self.reference_name = ImageSubscriber(
text="Reference Image",
doc="Image to reference for the *{O_INTENSITY}* method".format(**{"O_INTENSITY": O_INTENSITY})
)
self.gaussian_sigma = cellprofiler_core.setting.text.Float(
text="Segmentation distance transform smoothing factor",
value=1.,
doc="Sigma defines how 'smooth' the Gaussian kernel makes the image. Higher sigma means a smoother image."
)
self.min_dist = cellprofiler_core.setting.text.Integer(
text="Minimum distance between seeds",
value=1,
minval=0,
doc="""\
Minimum number of pixels separating peaks in a region of `2 * min_distance + 1 `
(i.e. peaks are separated by at least min_distance).
To find the maximum number of peaks, set this value to `1`.
"""
)
self.min_intensity = cellprofiler_core.setting.text.Float(
text="Minimum absolute internal distance",
value=0.,
minval=0.,
doc="""\
Minimum absolute intensity threshold for seed generation. Since this threshold is
applied to the distance transformed image, this defines a minimum object
"size". Objects smaller than this size will not contain seeds.
By default, the absolute threshold is the minimum value of the image.
For distance transformed images, this value is `0` (or the background).
"""
)
self.exclude_border = cellprofiler_core.setting.text.Integer(
text="Pixels from border to exclude",
value=0,
minval=0,
doc="Exclude seed generation from within `n` pixels of the image border."
)
self.max_seeds = cellprofiler_core.setting.text.Integer(
text="Maximum number of seeds",
value=-1,
doc="""\
Maximum number of seeds to generate. Default is no limit.
When the number of seeds exceeds this number, seeds are chosen
based on largest internal distance.
"""
)
self.structuring_element = cellprofiler_core.setting.StructuringElement(
text="Structuring element for seed dilation",
doc="""\
Structuring element to use for dilating the seeds.
Volumetric images will require volumetric structuring elements.
"""
)
self.connectivity = cellprofiler_core.setting.text.Integer(
text="Watershed connectivity",
value=1,
minval=1,
maxval=3,
doc="Connectivity for the watershed algorithm. Default is 1, maximum is number of dimensions of the image"
)
def create_settings(self):
self.image_name = ImageSubscriber("Image",
doc="""
The name of an image.
""")
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):
#
# The ImageSubscriber "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
"Input image name",
# HTML 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.
<br>
<b>ImageTemplate</b> will do something to this image.
""")
#
# The text.ImageName makes the image available to subsequent
# modules.
#
self.output_image_name = ImageName(
"Output image name",
# The second parameter holds a suggested name for the image.
"OutputImage",
doc="""This is the image resulting from the operation.""")
#
# Here's a choice box - the user gets a drop-down list of what
# can be done.
#
self.transform_choice = Choice(
"Transform choice",
# The choice takes a list of possibilities. The first one
# is the default - the one the user will typically choose.
[
M_FOURIER, M_SIMONCELLI_P, M_SIMONCELLI_R, M_TEST_FOURIER,
M_TEST_SIMONCELLI_P, M_TEST_SIMONCELLI_R, M_HAAR_S, M_HAAR_T,
M_TEST_HAAR, M_CHEBYSHEV_T
],
#
# Here, in the documentation, we do a little trick so that
# we use the actual text that's displayed in the documentation.
#
# %(GRADIENT_MAGNITUDE)s will get changed into "Gradient magnitude"
# etc. Python will look in globals() for the "GRADIENT_" names
# and paste them in where it sees %(GRADIENT_...)s
#
# The <ul> and <li> tags make a neat bullet-point list in the docs
#
doc='''There are several transforms available:
<ul><li><i>Fourier Transform:</i> Blabla. </li>
<li><i>Wavelet Transform:</i> Blabla. </li>
<li><i>Chebyshev Transform:</i> Blabla. </li></ul>''' % globals())
#
# We use a float setting so that the user can give us a number
# for the scale. The control will turn red if the user types in
# an invalid scale.
#
self.scale = Integer(
"Scale",
# The default value is 1 - a short-range scale
3,
# We don't let the user type in really small values
minval=1,
# or large values
maxval=100,
doc="""This is a scaling factor that supplies the sigma for
a gaussian that's used to smooth the image. The gradient is
calculated on the smoothed image, so large scales will give
you long-range gradients and small scales will give you
short-range gradients""")
self.M = Integer(
"Order",
# The default value is 1 - a short-range scale
0,
# We don't let the user type in really small values
minval=0,
# or large values
maxval=50,
doc=
"""This is the order of the Chebyshev Transform. A value of 0 will use the order matching the image dimensions."""
)
def create_settings(self):
"""Create the settings for the module
Create the settings for the module during initialization.
"""
self.image_name = ImageSubscriber(
"Select the input image",
"None",
doc="""\
The name of a binary image from a previous module. **IdentifyDeadWorms**
will use this image to establish the foreground and background for the
fitting operation. You can use **ApplyThreshold** to threshold a
grayscale image and create the binary mask. You can also use a module
such as **IdentifyPrimaryObjects** to label each worm and then use
**ConvertObjectsToImage** to make the result a mask.
""",
)
self.object_name = LabelName(
"Name the dead worm objects to be identified",
"DeadWorms",
doc="""\
This is the name for the dead worm objects. You can refer
to this name in subsequent modules such as
**IdentifySecondaryObjects**""",
)
self.worm_width = Integer(
"Worm width",
10,
minval=1,
doc="""\
This is the width (the short axis), measured in pixels,
of the diamond used as a template when
matching against the worm. It should be less than the width
of a worm.""",
)
self.worm_length = Integer(
"Worm length",
100,
minval=1,
doc="""\
This is the length (the long axis), measured in pixels,
of the diamond used as a template when matching against the
worm. It should be less than the length of a worm""",
)
self.angle_count = Integer(
"Number of angles",
32,
minval=1,
doc="""\
This is the number of different angles at which the template will be
tried. For instance, if there are 12 angles, the template will be
rotated by 0°, 15°, 30°, 45° … 165°. The shape is bilaterally symmetric;
that is, you will get the same shape after rotating it by 180°.
""",
)
self.wants_automatic_distance = Binary(
"Automatically calculate distance parameters?",
True,
doc="""\
This setting determines whether or not **IdentifyDeadWorms**
automatically calculates the parameters used to determine whether two
found-worm centers belong to the same worm.
Select "*Yes*" to have **IdentifyDeadWorms** automatically calculate
the distance from the worm length and width. Select "*No*" to set the
distances manually.
"""
% globals(),
)
self.space_distance = Float(
"Spatial distance",
5,
minval=1,
doc="""\
*(Used only if not automatically calculating distance parameters)*
Enter the distance for calculating the worm centers, in units of pixels.
The worm centers must be at least many pixels apart for the centers to
be considered two separate worms.
""",
)
self.angular_distance = Float(
"Angular distance",
30,
minval=1,
doc="""\
*(Used only if automatically calculating distance parameters)*
**IdentifyDeadWorms** calculates the worm centers at different angles.
Two worm centers are considered to represent different worms if their
angular distance is larger than this number. The number is measured in
degrees.
""",
)