def add_channel(self, can_remove=True):
"""Add another channel to the channels list"""
group = cps.SettingsGroup()
group.can_remove = can_remove
group.append(
"channel_choice",
cps.Integer(
text="Channel number",
value=len(self.channels) + 1,
minval=1,
doc="""\
*(Used only when splitting images)*
This setting chooses a channel to be processed. For example, *1*
is the first
channel in a .TIF or the red channel in a traditional image file.
*2* and *3* are the second and third channels of a TIF or
the green and blue channels in other formats. *4* is the
transparency channel for image formats that support transparency and is
channel # 4 for a .TIF file. **ColorToGray** will fail to process an
image if you select a channel that is not supported by that image, for
example, “5” for a three-channel .PNG file.""",
),
)
group.append(
"contribution",
cps.Float(
"Relative weight of the channel",
1,
0,
doc="""\
*(Used only when combining channels)*
Relative weights: 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.""",
),
)
group.append(
"image_name",
cps.ImageNameProvider(
"Image name",
value="Channel%d" % (len(self.channels) + 1),
doc="""\
*(Used only when splitting images)*
Select the name of the output grayscale image.""",
),
)
if group.can_remove:
group.append(
"remover",
cps.RemoveSettingButton("", "Remove this channel",
self.channels, group),
)
self.channels.append(group)
def create_settings(self):
self.site_count = cps.Integer(
"Number of image sites per well",
1,
minval=1,
doc="""\
Enter the number of image sets (fields of view) corresponding to each well.""",
)
self.column_count = cps.Integer(
"Number of columns per plate",
12,
minval=1,
doc="""\
Enter the number of columns per plate.""",
)
self.row_count = cps.Integer(
"Number of rows per plate",
8,
minval=1,
doc="""\
Enter the number of rows per plate.""",
)
self.order = cps.Choice(
"Order of image data",
[O_ROW, O_COLUMN],
doc="""\
This setting specifies how the input data is ordered (assuming that
sites within a well are ordered consecutively):
- *%(O_ROW)s:* The data appears by row and then by column. That is,
all columns for a given row (e.g., A01, A02, A03…) appear
consecutively, for each row in consecutive order.
- *%(O_COLUMN)s:* The data appears by column and then by row. That is,
all rows for a given column (e.g., A01, B01, C01…) appear
consecutively, for each column in consecutive order.
For instance, the SBS Bioimage example (available `here`_) has files that are named:
Channel1-01-A01.tif, Channel1-02-A02.tif, …, Channel1-12-A12.tif, Channel1-13-B01.tif, …
You would use “%(O_ROW)s” to label these because the ordering is by row and then by column.
.. _here: http://cellprofiler.org/examples.html#SBS_Bioimage_CNT
""" % globals(),
)
def create_settings(self):
"""Create the module settings and name the module"""
self.wants_default_output_directory = cps.Binary(
"Store batch files in default output folder?",
True,
doc="""\
Select "*Yes*" to store batch files in the Default Output folder.
Select "*No*" to enter the path to the folder that will be used to
store these files. The Default Output folder can be set by clicking the "View output settings" button in the main CP window, or in CellProfiler Preferences. """
% globals(),
)
self.custom_output_directory = cps.Text(
"Output folder path",
cpprefs.get_default_output_directory(),
doc=
"Enter the path to the output folder. (Used only if not using the default output folder)",
)
# Worded this way not because I am windows-centric but because it's
# easier than listing every other OS in the universe except for VMS
self.remote_host_is_windows = cps.Binary(
"Are the cluster computers running Windows?",
False,
doc="""\
Select "*Yes*" if the cluster computers are running one of the
Microsoft Windows operating systems. In this case, **CreateBatchFiles**
will modify all paths to use the Windows file separator (backslash \\\\ ).
Select "*No*" for **CreateBatchFiles** to modify all paths to use the
Unix or Macintosh file separator (slash / ).""" % globals(),
)
self.batch_mode = cps.Binary("Hidden: in batch mode", False)
self.distributed_mode = cps.Binary("Hidden: in distributed mode",
False)
self.default_image_directory = cps.Setting(
"Hidden: default input folder at time of save",
cpprefs.get_default_image_directory(),
)
self.revision = cps.Integer("Hidden: revision number", 0)
self.from_old_matlab = cps.Binary("Hidden: from old matlab", False)
self.acknowledge_old_matlab = cps.DoSomething(
"Could not update CP1.0 pipeline to be compatible with CP2.0. See module notes.",
"OK",
self.clear_old_matlab,
)
self.mappings = []
self.add_mapping()
self.add_mapping_button = cps.DoSomething(
"",
"Add another path mapping",
self.add_mapping,
doc="""\
Use this option if another path must be mapped because there is a difference
between how the local computer sees a folder location vs. how the cluster
computer sees the folder location.""",
)
def create_settings(self):
self.omero_host = cps.Text(
"Host address",
DEFAULT_OMERO_HOST,
doc=
"""Host address of an omero server. Can be an ip-address or a hostname.""",
)
self.omero_port = cps.Integer("Port",
DEFAULT_OMERO_PORT,
doc="""Port of an omero server.""")
self.omero_username = cps.Text(
"Username",
DEFAULT_OMERO_USERNAME,
doc="""Username is required for login into an omero server.""",
)
self.omero_password = cps.Text(
"Password",
DEFAULT_OMERO_PASSWORD,
doc="""Password is required for login into an omero server.""",
)
self.omero_object = cps.Choice("Object to load",
[MS_IMAGE, MS_DATASET, MS_PLATE],
DEFAULT_OMERO_OBJECT)
self.omero_object_id = cps.Integer(
"Object id",
DEFAULT_OMERO_OBJECT_ID,
doc=
"""This is a number that omero uses to uniquely identify an object, be it a dataset, plate, or image.""",
)
self.load_channels = cps.DoSomething("", "Load channels from OMERO",
self.load_channels)
# All the omero images that are loaded are assumed to have
# as many or more channels than the highest channel number
# the user specifies.
self.channels = []
self.channel_count = cps.HiddenCount(self.channels, "Channel count")
# Add the first channel
self.add_channelfn(False)
# Button for adding other channels
self.add_channel = cps.DoSomething("", "Add another channel",
self.add_channelfn)
def create_settings(self):
self.x_object = cps.ObjectNameSubscriber(
"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 = cps.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 = cps.ObjectNameSubscriber(
"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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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):
"""Create your settings by subclassing this function
create_settings is called at the end of initialization.
"""
self.grid_image = cps.GridNameProvider(
"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 = cps.Integer(
"Number of rows",
8,
1,
doc="""Along the height of the grid, define the number of rows.""",
)
self.grid_columns = cps.Integer(
"Number of columns",
12,
1,
doc=
"""Along the width of the grid, define the number of columns.""",
)
self.origin = cps.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 = cps.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 = cps.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 = cps.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 = cps.ObjectNameSubscriber(
"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 = cps.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 = cps.ImageNameSubscriber(
"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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.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 = cps.ImageNameSubscriber(
"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 = cps.ImageNameProvider(
"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 = cps.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 add_single_measurement(self, can_delete=True):
"""Add a single measurement to the group of single measurements
can_delete - True to include a "remove" button, False if you're not
allowed to remove it.
"""
group = cps.SettingsGroup()
if can_delete:
group.append("divider", cps.Divider(line=True))
group.append(
"object_name",
cps.ObjectNameSubscriber(
"Select the object to be classified",
"None",
doc="""\
The name of the objects to be classified. You can choose from objects
created by any previous module. See **IdentifyPrimaryObjects**,
**IdentifySecondaryObjects**, **IdentifyTertiaryObjects**, or **Watershed**
""",
),
)
def object_fn():
return group.object_name.value
group.append(
"measurement",
cps.Measurement(
"Select the measurement to classify by",
object_fn,
doc="""\
*(Used only if using a single measurement)*
Select a measurement made by a previous module. The objects will be
classified according to their values for this measurement.
""",
),
)
group.append(
"bin_choice",
cps.Choice(
"Select bin spacing",
[BC_EVEN, BC_CUSTOM],
doc="""\
*(Used only if using a single measurement)*
Select how you want to define the spacing of the bins. You have the
following options:
- *%(BC_EVEN)s:* Choose this if you want to specify bins of equal
size, bounded by upper and lower limits. If you want two bins, choose
this option and then provide a single threshold when asked.
- *%(BC_CUSTOM)s:* Choose this option to create the indicated number
of bins at evenly spaced intervals between the low and high
threshold. You also have the option to create bins for objects that
fall below or above the low and high threshold.
""" % globals(),
),
)
group.append(
"bin_count",
cps.Integer(
"Number of bins",
3,
minval=1,
doc="""\
*(Used only if using a single measurement)*
This is the number of bins that will be created between
the low and high threshold""",
),
)
group.append(
"low_threshold",
cps.Float(
"Lower threshold",
0,
doc="""\
*(Used only if using a single measurement and "%(BC_EVEN)s" selected)*
This is the threshold that separates the lowest bin from the others. The
lower threshold, upper threshold, and number of bins define the
thresholds of bins between the lowest and highest.
""" % globals(),
),
)
group.append(
"wants_low_bin",
cps.Binary(
"Use a bin for objects below the threshold?",
False,
doc="""\
*(Used only if using a single measurement)*
Select "*Yes*" if you want to create a bin for objects whose values
fall below the low threshold. Select "*No*" if you do not want a bin
for these objects.
""" % globals(),
),
)
def min_upper_threshold():
return group.low_threshold.value + np.finfo(float).eps
group.append(
"high_threshold",
cps.Float(
"Upper threshold",
1,
minval=cps.NumberConnector(min_upper_threshold),
doc="""\
*(Used only if using a single measurement and "%(BC_EVEN)s" selected)*
This is the threshold that separates the last bin from the others. Note
that if you would like two bins, you should select "*%(BC_CUSTOM)s*".
""" % globals(),
),
)
group.append(
"wants_high_bin",
cps.Binary(
"Use a bin for objects above the threshold?",
False,
doc="""\
*(Used only if using a single measurement)*
Select "*Yes*" if you want to create a bin for objects whose values
are above the high threshold.
Select "*No*" if you do not want a bin for these objects.
""" % globals(),
),
)
group.append(
"custom_thresholds",
cps.Text(
"Enter the custom thresholds separating the values between bins",
"0,1",
doc="""\
*(Used only if using a single measurement and "%(BC_CUSTOM)s" selected)*
This setting establishes the threshold values for the bins. You should
enter one threshold between each bin, separating thresholds with commas
(for example, *0.3, 1.5, 2.1* for four bins). The module will create one
more bin than there are thresholds.
""" % globals(),
),
)
group.append(
"wants_custom_names",
cps.Binary(
"Give each bin a name?",
False,
doc="""\
*(Used only if using a single measurement)*
Select "*Yes*" to assign custom names to bins you have specified.
Select "*No*" for the module to automatically assign names based on
the measurements and the bin number.
""" % globals(),
),
)
group.append(
"bin_names",
cps.Text(
"Enter the bin names separated by commas",
"None",
doc="""\
*(Used only if "Give each bin a name?" is checked)*
Enter names for each of the bins, separated by commas.
An example including three bins might be *First,Second,Third*.""",
),
)
group.append(
"wants_images",
cps.Binary(
"Retain an image of the classified objects?",
False,
doc="""\
Select "*Yes*" to keep an image of the objects which is color-coded
according to their classification, for use later in the pipeline (for
example, to be saved by a **SaveImages** module).
""" % globals(),
),
)
group.append(
"image_name",
cps.ImageNameProvider(
"Name the output image",
"ClassifiedNuclei",
doc=
"""Enter the name to be given to the classified object image.""",
),
)
group.can_delete = can_delete
def number_of_bins():
"""Return the # of bins in this classification"""
if group.bin_choice == BC_EVEN:
value = group.bin_count.value
else:
value = len(group.custom_thresholds.value.split(",")) - 1
if group.wants_low_bin:
value += 1
if group.wants_high_bin:
value += 1
return value
group.number_of_bins = number_of_bins
def measurement_name():
"""Get the measurement name to use inside the bin name
Account for conflicts with previous measurements
"""
measurement_name = group.measurement.value
other_same = 0
for other in self.single_measurements:
if id(other) == id(group):
break
if other.measurement.value == measurement_name:
other_same += 1
if other_same > 0:
measurement_name += str(other_same)
return measurement_name
def bin_feature_names():
"""Return the feature names for each bin"""
if group.wants_custom_names:
return [
name.strip() for name in group.bin_names.value.split(",")
]
return [
"_".join((measurement_name(), "Bin_%d" % (i + 1)))
for i in range(number_of_bins())
]
group.bin_feature_names = bin_feature_names
def validate_group():
bin_name_count = len(bin_feature_names())
bin_count = number_of_bins()
if bin_count < 1:
bad_setting = (group.bin_count if group.bin_choice == BC_EVEN
else group.custom_thresholds)
raise cps.ValidationError(
"You must have at least one bin in order to take measurements. "
"Either add more bins or ask for bins for objects above or below threshold",
bad_setting,
)
if bin_name_count != number_of_bins():
raise cps.ValidationError(
"The number of bin names (%d) does not match the number of bins (%d)."
% (bin_name_count, bin_count),
group.bin_names,
)
for bin_feature_name in bin_feature_names():
cps.AlphanumericText.validate_alphanumeric_text(
bin_feature_name, group.bin_names, True)
if group.bin_choice == BC_CUSTOM:
try:
[
float(x.strip())
for x in group.custom_thresholds.value.split(",")
]
except ValueError:
raise cps.ValidationError(
"Custom thresholds must be a comma-separated list "
'of numbers (example: "1.0, 2.3, 4.5")',
group.custom_thresholds,
)
group.validate_group = validate_group
if can_delete:
group.remove_settings_button = cps.RemoveSettingButton(
"", "Remove this classification", self.single_measurements,
group)
self.single_measurements.append(group)
def create_settings(self):
self.objects_name = cps.ObjectNameSubscriber(
"Select the input objects",
"None",
doc="""\
Select the objects you would like to split or merge (that is,
whose object numbers you want to reassign). You can
use any objects that were created in previous modules, such as
**IdentifyPrimaryObjects** or **IdentifySecondaryObjects**.""",
)
self.output_objects_name = cps.ObjectNameProvider(
"Name the new objects",
"RelabeledNuclei",
doc="""\
Enter a name for the objects that have been split or merged (that is,
whose numbers have been reassigned).
You can use this name in subsequent modules that take objects as inputs.""",
)
self.relabel_option = cps.Choice(
"Operation",
[OPTION_MERGE, OPTION_SPLIT],
doc="""\
You can choose one of the following options:
- *%(OPTION_MERGE)s:* Assign adjacent or nearby objects the same label
based on certain criteria. It can be useful, for example, to merge
together touching objects that were incorrectly split into two pieces
by an **Identify** module.
- *%(OPTION_SPLIT)s:* Assign a unique number to separate objects that
currently share the same label. This can occur if you applied certain
operations in the **Morph** module to objects.""" % globals(),
)
self.merge_option = cps.Choice(
"Merging method",
[UNIFY_DISTANCE, UNIFY_PARENT],
doc="""\
*(Used only with the "%(OPTION_MERGE)s" option)*
You can merge objects in one of two ways:
- *%(UNIFY_DISTANCE)s:* All objects within a certain pixel radius from
each other will be merged.
- *%(UNIFY_PARENT)s:* All objects which share the same parent
relationship to another object will be merged. This is not to be
confused with using the **RelateObjects** module, in which the
related objects remain as individual objects. See **RelateObjects**
for more details.""" % globals(),
)
self.merging_method = cps.Choice(
"Output object type",
[UM_DISCONNECTED, UM_CONVEX_HULL],
doc="""\
*(Used only with the "%(UNIFY_PARENT)s" merging method)*
**SplitOrMergeObjects** can either merge the child objects and keep them
disconnected or it can find the smallest convex polygon (the convex
hull) that encloses all of a parent’s child objects. The convex hull
will be truncated to include only those pixels in the parent - in that
case it may not truly be convex. Choose *%(UM_DISCONNECTED)s* to leave
the children as disconnected pieces. Choose *%(UM_CONVEX_HULL)s* to
create an output object that is the convex hull around them all.""" %
globals(),
)
self.parent_object = cps.Choice(
"Select the parent object",
["None"],
choices_fn=self.get_parent_choices,
doc="""\
Select the parent object that will be used to merge the child objects.
Please note the following:
- You must have established a parent-child relationship between the
objects using a prior **RelateObjects** module.
- Primary objects and their associated secondary objects are already in
a one-to-one parent-child relationship, so it makes no sense to merge
them here.""",
)
self.distance_threshold = cps.Integer(
"Maximum distance within which to merge objects",
0,
minval=0,
doc="""\
*(Used only with the "%(OPTION_MERGE)s" option and the "%(UNIFY_DISTANCE)s"
method)*
Objects that are less than or equal to the distance you enter here, in
pixels, will be merged. If you choose zero (the default), only objects
that are touching will be merged. Note that *%(OPTION_MERGE)s* will
not actually connect or bridge the two objects by adding any new pixels;
it simply assigns the same object number to the portions of the object.
The new, merged object may therefore consist of two or more unconnected
components. If you want to add pixels around objects, see
**ExpandOrShrink** or **Morph**.""" % globals(),
)
self.wants_image = cps.Binary(
"Merge using a grayscale image?",
False,
doc="""\
*(Used only with the "%(OPTION_MERGE)s" option)*
Select *Yes* to use the objects’ intensity features to determine
whether two objects should be merged. If you choose to use a grayscale
image, *%(OPTION_MERGE)s* will merge two objects only if they are
within the distance you have specified *and* certain criteria about the
objects within the grayscale image are met.""" % globals(),
)
self.image_name = cps.ImageNameSubscriber(
"Select the grayscale image to guide merging",
"None",
doc="""\
*(Used only if a grayscale image is to be used as a guide for
merging)*
Select the name of an image loaded or created by a previous module.""",
)
self.minimum_intensity_fraction = cps.Float(
"Minimum intensity fraction",
0.9,
minval=0,
maxval=1,
doc="""\
*(Used only if a grayscale image is to be used as a guide for
merging)*
Select the minimum acceptable intensity fraction. This will be used as
described for the method you choose in the next setting.""",
)
self.where_algorithm = cps.Choice(
"Method to find object intensity",
[CA_CLOSEST_POINT, CA_CENTROIDS],
doc="""\
*(Used only if a grayscale image is to be used as a guide for
merging)*
You can use one of two methods to determine whether two objects should
merged, assuming they meet the distance criteria (as specified
above):
- *%(CA_CENTROIDS)s:* When the module considers merging two objects,
this method identifies the centroid of each object, records the
intensity value of the dimmer of the two centroids, multiplies this
value by the *minimum intensity fraction* to generate a threshold,
and draws a line between the centroids. The method will merge the two
objects only if the intensity of every point along the line is above
the threshold. For instance, if the intensity of one centroid is 0.75
and the other is 0.50 and the *minimum intensity fraction* has been
chosen to be 0.9, all points along the line would need to have an
intensity of min(0.75, 0.50) \* 0.9 = 0.50 \* 0.9 = 0.45.
This method works well for round cells whose maximum intensity is in
the center of the cell: a single cell that was incorrectly segmented
into two objects will typically not have a dim line between the
centroids of the two halves and will be correctly merged.
- *%(CA_CLOSEST_POINT)s:* This method is useful for unifying
irregularly shaped cells that are connected. It starts by assigning
background pixels in the vicinity of the objects to the nearest
object. Objects are then merged if each object has background pixels
that are:
- Within a distance threshold from each object;
- Above the minimum intensity fraction of the nearest object pixel;
- Adjacent to background pixels assigned to a neighboring object.
An example of a feature that satisfies the above constraints is a
line of pixels that connects two neighboring objects and is roughly
the same intensity as the boundary pixels of both (such as an axon
connecting two neurons' soma).""" % globals(),
)
def create_settings(self):
self.object_name = cps.ObjectNameSubscriber(
"Select objects to measure",
"None",
doc="""\
Select the objects whose neighbors you want to measure.""",
)
self.neighbors_name = cps.ObjectNameSubscriber(
"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 = 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* 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""",
)
self.wants_excluded_objects = cps.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):
# XXX needs to use cps.SettingsGroup
class Operand(object):
"""Represents the collection of settings needed by each operand"""
def __init__(self, index, operation):
self.__index = index
self.__operation = operation
self.__operand_choice = cps.Choice(
self.operand_choice_text(),
MC_ALL,
doc="""Indicate whether the operand is an image or object measurement.""",
)
self.__operand_objects = cps.ObjectNameSubscriber(
self.operand_objects_text(),
"None",
doc="""Choose the objects you want to measure for this operation.""",
)
self.__operand_measurement = cps.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 = cps.Float(
"Multiply the above operand by",
1,
doc="""Enter the number by which you would like to multiply the above operand.""",
)
self.__exponent = cps.Float(
"Raise the power of above operand by",
1,
doc="""Enter the power by which you would like to raise the above operand.""",
)
@property
def operand_choice(self):
"""Either MC_IMAGE for image measurements or MC_OBJECT for object"""
return self.__operand_choice
@property
def operand_objects(self):
"""Get measurements from these objects"""
return self.__operand_objects
@property
def operand_measurement(self):
"""The measurement providing the value of the operand"""
return self.__operand_measurement
@property
def multiplicand(self):
"""Premultiply the measurement by this value"""
return self.__multiplicand
@property
def exponent(self):
"""Raise the measurement to this power"""
return self.__exponent
@property
def object(self):
"""The name of the object for measurement or "Image\""""
if self.operand_choice == MC_IMAGE:
return cpmeas.IMAGE
else:
return self.operand_objects.value
def object_fn(self):
if self.__operand_choice == MC_IMAGE:
return cpmeas.IMAGE
elif self.__operand_choice == MC_OBJECT:
return self.__operand_objects.value
else:
raise NotImplementedError(
"Measurement type %s is not supported"
% self.__operand_choice.value
)
def operand_name(self):
"""A fancy name based on what operation is being performed"""
if self.__index == 0:
return (
"first operand"
if self.__operation in (O_ADD, O_MULTIPLY)
else "minuend"
if self.__operation == O_SUBTRACT
else "numerator"
)
elif self.__index == 1:
return (
"second operand"
if self.__operation in (O_ADD, O_MULTIPLY)
else "subtrahend"
if self.__operation == O_SUBTRACT
else "denominator"
)
def operand_choice_text(self):
return self.operand_text("Select the %s measurement type")
def operand_objects_text(self):
return self.operand_text("Select the %s objects")
def operand_text(self, format):
return format % self.operand_name()
def operand_measurement_text(self):
return self.operand_text("Select the %s measurement")
def settings(self):
"""The operand settings to be saved in the output file"""
return [
self.operand_choice,
self.operand_objects,
self.operand_measurement,
self.multiplicand,
self.exponent,
]
def visible_settings(self):
"""The operand settings to be displayed"""
self.operand_choice.text = self.operand_choice_text()
self.operand_objects.text = self.operand_objects_text()
self.operand_measurement.text = self.operand_measurement_text()
result = [self.operand_choice]
result += (
[self.operand_objects] if self.operand_choice == MC_OBJECT else []
)
result += [self.operand_measurement, self.multiplicand, self.exponent]
return result
self.output_feature_name = cps.AlphanumericText(
"Name the output measurement",
"Measurement",
doc="""Enter a name for the measurement calculated by this module.""",
)
self.operation = cps.Choice(
"Operation",
O_ALL,
doc="""\
Choose the arithmetic operation you would like to perform. *None* is
useful if you simply want to select some of the later options in the
module, such as multiplying or exponentiating your image by a constant.
""",
)
self.operands = (Operand(0, self.operation), Operand(1, self.operation))
self.spacer_1 = cps.Divider(line=True)
self.spacer_2 = cps.Divider(line=True)
self.spacer_3 = cps.Divider(line=True)
self.wants_log = cps.Binary(
"Take log10 of result?",
False,
doc="""Select *Yes* if you want the log (base 10) of the result."""
% globals(),
)
self.final_multiplicand = cps.Float(
"Multiply the result by",
1,
doc="""\
*(Used only for operations other than "None")*
Enter the number by which you would like to multiply the result.
""",
)
self.final_exponent = cps.Float(
"Raise the power of result by",
1,
doc="""\
*(Used only for operations other than "None")*
Enter the power by which you would like to raise the result.
""",
)
self.final_addend = cps.Float(
"Add to the result",
0,
doc="""Enter the number you would like to add to the result.""",
)
self.constrain_lower_bound = cps.Binary(
"Constrain the result to a lower bound?",
False,
doc="""Select *Yes* if you want the result to be constrained to a lower bound."""
% globals(),
)
self.lower_bound = cps.Float(
"Enter the lower bound",
0,
doc="""Enter the lower bound of the result here.""",
)
self.constrain_upper_bound = cps.Binary(
"Constrain the result to an upper bound?",
False,
doc="""Select *Yes* if you want the result to be constrained to an upper bound."""
% globals(),
)
self.upper_bound = cps.Float(
"Enter the upper bound",
1,
doc="""Enter the upper bound of the result here.""",
)
self.rounding = cps.Choice(
"How should the output value be rounded?",
ROUNDING,
doc="""\
Choose how the values should be rounded- not at all, to a specified number of decimal places,
to the next lowest integer ("floor rounding"), or to the next highest integer ("ceiling rounding").
Note that for rounding to an arbitrary number of decimal places, Python uses "round to even" rounding,
such that ties round to the nearest even number. Thus, 1.5 and 2.5 both round to to 2 at 0 decimal
places, 2.45 rounds to 2.4, 2.451 rounds to 2.5, and 2.55 rounds to 2.6 at 1 decimal place. See the
numpy documentation for more information.
""",
)
self.rounding_digit = cps.Integer(
"Enter how many decimal places the value should be rounded to",
0,
doc="""\
Enter how many decimal places the value should be rounded to. 0 will round to an integer (e.g. 1, 2), 1 to
one decimal place (e.g. 0.1, 0.2), -1 to one value before the decimal place (e.g. 10, 20), etc.
""",
)
def create_settings(self):
"""Create the settings for the module
Create the settings for the module during initialization.
"""
self.image_name = cps.ImageNameSubscriber(
"Select the input image",
"None",
doc="""\
The name of a binary image from a previous module. **IdentifyDeadWorms**
will use this image to establish the foreground and background for the
fitting operation. You can use **ApplyThreshold** to threshold a
grayscale image and create the binary mask. You can also use a module
such as **IdentifyPrimaryObjects** to label each worm and then use
**ConvertObjectsToImage** to make the result a mask.
""",
)
self.object_name = cps.ObjectNameProvider(
"Name the dead worm objects to be identified",
"DeadWorms",
doc="""\
This is the name for the dead worm objects. You can refer
to this name in subsequent modules such as
**IdentifySecondaryObjects**""",
)
self.worm_width = cps.Integer(
"Worm width",
10,
minval=1,
doc="""\
This is the width (the short axis), measured in pixels,
of the diamond used as a template when
matching against the worm. It should be less than the width
of a worm.""",
)
self.worm_length = cps.Integer(
"Worm length",
100,
minval=1,
doc="""\
This is the length (the long axis), measured in pixels,
of the diamond used as a template when matching against the
worm. It should be less than the length of a worm""",
)
self.angle_count = cps.Integer(
"Number of angles",
32,
minval=1,
doc="""\
This is the number of different angles at which the template will be
tried. For instance, if there are 12 angles, the template will be
rotated by 0°, 15°, 30°, 45° … 165°. The shape is bilaterally symmetric;
that is, you will get the same shape after rotating it by 180°.
""",
)
self.wants_automatic_distance = cps.Binary(
"Automatically calculate distance parameters?",
True,
doc="""\
This setting determines whether or not **IdentifyDeadWorms**
automatically calculates the parameters used to determine whether two
found-worm centers belong to the same worm.
Select "*Yes*" to have **IdentifyDeadWorms** automatically calculate
the distance from the worm length and width. Select "*No*" to set the
distances manually.
""" % globals(),
)
self.space_distance = cps.Float(
"Spatial distance",
5,
minval=1,
doc="""\
*(Used only if not automatically calculating distance parameters)*
Enter the distance for calculating the worm centers, in units of pixels.
The worm centers must be at least many pixels apart for the centers to
be considered two separate worms.
""",
)
self.angular_distance = cps.Float(
"Angular distance",
30,
minval=1,
doc="""\
*(Used only if automatically calculating distance parameters)*
**IdentifyDeadWorms** calculates the worm centers at different angles.
Two worm centers are considered to represent different worms if their
angular distance is larger than this number. The number is measured in
degrees.
""",
)
def create_settings(self):
"""Create your settings by subclassing this function
create_settings is called at the end of initialization.
"""
self.grid_name = cps.GridNameSubscriber(
"Select the defined grid",
"None",
doc="""Select the name of a grid created by a previous **DefineGrid** module.""",
)
self.output_objects_name = cps.ObjectNameProvider(
"Name the objects to be identified",
"Wells",
doc="""\
Enter the name of the grid objects identified by this module. These objects
will be available for further measurement and processing in subsequent modules.""",
)
self.shape_choice = cps.Choice(
"Select object shapes and locations",
[SHAPE_RECTANGLE, SHAPE_CIRCLE_FORCED, SHAPE_CIRCLE_NATURAL, SHAPE_NATURAL],
doc="""\
Use this setting to choose the method to be used to determine the grid
objects’ shapes and locations:
- *%(SHAPE_RECTANGLE)s:* Each object will be created as a rectangle,
completely occupying the entire grid compartment (rectangle). This
option creates the rectangular objects based solely on the grid’s
specifications, not on any previously identified guiding objects.
- *%(SHAPE_CIRCLE_FORCED)s:* Each object will be created as a circle,
centered in the middle of each grid compartment. This option places
the circular objects’ locations based solely on the grid’s
specifications, not on any previously identified guiding objects. The
radius of all circles in a grid will be constant for the entire grid
in each image cycle, and can be determined automatically for each
image cycle based on the average radius of previously identified
guiding objects for that image cycle, or instead it can be specified
as a single radius for all circles in all grids in the entire
analysis run.
- *%(SHAPE_CIRCLE_NATURAL)s:* Each object will be created as a
circle, and each circle’s location within its grid compartment will
be determined based on the location of any previously identified
guiding objects within that grid compartment. Thus, if a guiding
object lies within a particular grid compartment, that object’s
center will be the center of the created circular object. If no
guiding objects lie within a particular grid compartment, the
circular object is placed within the center of that grid compartment.
If more than one guiding object lies within the grid compartment,
they will be combined and the centroid of this combined object will
be the location of the created circular object. Note that guiding
objects whose centers are close to the grid edge are ignored.
- *%(SHAPE_NATURAL)s:* Within each grid compartment, the object will
be identified based on combining all of the parts of guiding objects,
if any, that fall within the grid compartment. Note that guiding
objects whose centers are close to the grid edge are ignored. If a
guiding object does not exist within a grid compartment, an object
consisting of one single pixel in the middle of the grid compartment
will be created.
"""
% globals(),
)
self.diameter_choice = cps.Choice(
"Specify the circle diameter automatically?",
[AM_AUTOMATIC, AM_MANUAL],
doc="""\
*(Used only if "Circle" is selected as object shape)*
There are two methods for selecting the circle diameter:
- *%(AM_AUTOMATIC)s:* Uses the average diameter of previously
identified guiding objects as the diameter.
- *%(AM_MANUAL)s:* Lets you specify the diameter directly, as a
number.
"""
% globals(),
)
self.diameter = cps.Integer(
"Circle diameter",
20,
minval=2,
doc="""\
*(Used only if "Circle" is selected as object shape and diameter is
specified manually)*
Enter the diameter to be used for each grid circle, in pixels.
%(HELP_ON_MEASURING_DISTANCES)s
"""
% globals(),
)
self.guiding_object_name = cps.ObjectNameSubscriber(
"Select the guiding objects",
"None",
doc="""\
*(Used only if "Circle" is selected as object shape and diameter is
specified automatically, or if "Natural Location" is selected as the
object shape)*
Select the names of previously identified objects that will be used to
guide the shape and/or location of the objects created by this module,
depending on the method chosen.
""",
)
def add_function(self, can_remove=True):
group = MorphSettingsGroup()
group.can_remove = can_remove
if can_remove:
group.append("divider", cps.Divider(line=False))
group.append(
"function",
cps.Choice(
"Select the operation to perform",
F_ALL,
doc=
"""Choose one of the operations described in this module's help.""",
),
)
group.append(
"repeats_choice",
cps.Choice(
"Number of times to repeat operation",
R_ALL,
doc="""\
This setting controls the number of times that the same operation is
applied successively to the image.
- *%(R_ONCE)s:* Perform the operation once on the image.
- *%(R_FOREVER)s:* Perform the operation on the image until successive
iterations yield the same image.
- *%(R_CUSTOM)s:* Perform the operation a custom number of times.""" %
globals(),
),
)
group.append(
"custom_repeats",
cps.Integer(self.CUSTOM_REPEATS_TEXT,
2,
1,
doc=self.CUSTOM_REPEATS_DOC),
)
group.append(
"rescale_values",
cps.Binary(
"Rescale values from 0 to 1?",
True,
doc="""\
*(Used only for the "%(F_DISTANCE)s" operation).*
Select "*Yes*" to rescale the transformed values to lie between 0 and
1. This is the option to use if the distance transformed image is to be
used for thresholding by an **Identify** module or the like, which
assumes a 0-1 scaling.
Select "*No*" to leave the values in absolute pixel units. This useful
in cases where the actual pixel distances are to be used downstream as
input for a measurement module.""" % globals(),
),
)
if can_remove:
group.append(
"remove",
cps.RemoveSettingButton("", "Remove this operation",
self.functions, group),
)
self.functions.append(group)
def add_image(self, can_remove=True):
group = GranularitySettingsGroup()
group.can_remove = can_remove
if can_remove:
group.append("divider", cps.Divider(line=True))
group.append(
"image_name",
cps.ImageNameSubscriber(
"Select an image to measure",
"None",
doc=
"Select the grayscale images whose granularity you want to measure.",
),
)
group.append(
"subsample_size",
cps.Float(
"Subsampling factor for granularity measurements",
0.25,
minval=np.finfo(float).eps,
maxval=1,
doc="""\
If the textures of interest are larger than a few pixels, we recommend
you subsample the image with a factor <1 to speed up the processing.
Down sampling the image will let you detect larger structures with a
smaller sized structure element. A factor >1 might increase the accuracy
but also require more processing time. Images are typically of higher
resolution than is required for granularity measurements, so the default
value is 0.25. For low-resolution images, increase the subsampling
fraction; for high-resolution images, decrease the subsampling fraction.
Subsampling by 1/4 reduces computation time by (1/4) :sup:`3` because the
size of the image is (1/4) :sup:`2` of original and the range of granular
spectrum can be 1/4 of original. Moreover, the results are sometimes
actually a little better with subsampling, which is probably because
with subsampling the individual granular spectrum components can be used
as features, whereas without subsampling a feature should be a sum of
several adjacent granular spectrum components. The recommendation on the
numerical value cannot be determined in advance; an analysis as in this
reference may be required before running the whole set. See this `pdf`_,
slides 27-31, 49-50.
.. _pdf: http://www.ravkin.net/presentations/Statistical%20properties%20of%20algorithms%20for%20analysis%20of%20cell%20images.pdf""",
),
)
group.append(
"image_sample_size",
cps.Float(
"Subsampling factor for background reduction",
0.25,
minval=np.finfo(float).eps,
maxval=1,
doc="""\
It is important to remove low frequency image background variations as
they will affect the final granularity measurement. Any method can be
used as a pre-processing step prior to this module; we have chosen to
simply subtract a highly open image. To do it quickly, we subsample the
image first. The subsampling factor for background reduction is usually
[0.125 – 0.25]. This is highly empirical, but a small factor should be
used if the structures of interest are large. The significance of
background removal in the context of granulometry is that image volume
at certain granular size is normalized by total image volume, which
depends on how the background was removed.""",
),
)
group.append(
"element_size",
cps.Integer(
"Radius of structuring element",
10,
minval=1,
doc="""\
This radius should correspond to the radius of the textures of interest
*after* subsampling; i.e., if textures in the original image scale have
a radius of 40 pixels, and a subsampling factor of 0.25 is used, the
structuring element size should be 10 or slightly smaller, and the range
of the spectrum defined below will cover more sizes.""",
),
)
group.append(
"granular_spectrum_length",
cps.Integer(
"Range of the granular spectrum",
16,
minval=1,
doc="""\
You may need a trial run to see which granular
spectrum range yields informative measurements. Start by using a wide spectrum and
narrow it down to the informative range to save time.""",
),
)
group.append(
"add_objects_button",
cps.DoSomething(
"",
"Add another object",
group.add_objects,
doc="""\
Press this button to add granularity measurements for objects, such as
those identified by a prior **IdentifyPrimaryObjects** module.
**MeasureGranularity** will measure the image’s granularity within each
object at the requested scales.""",
),
)
group.objects = []
group.object_count = cps.HiddenCount(group.objects, "Object count")
if can_remove:
group.append(
"remover",
cps.RemoveSettingButton("", "Remove this image", self.images,
group),
)
self.images.append(group)
return group
def create_settings(self):
"""Create the UI settings for the module"""
self.seed_objects_name = cps.ObjectNameSubscriber(
"Select the seed objects",
"None",
doc="""\
Select the previously identified objects that you want to use as the
seeds for measuring branches and distances. Branches and trunks are assigned
per seed object. Seed objects are typically not single points/pixels but
instead are usually objects of varying sizes.""",
)
self.image_name = cps.ImageNameSubscriber(
"Select the skeletonized image",
"None",
doc="""\
Select the skeletonized image of the dendrites and/or axons as produced
by the **Morph** module’s *Skel* operation.""",
)
self.wants_branchpoint_image = cps.Binary(
"Retain the branchpoint image?",
False,
doc="""\
Select "*Yes*" if you want to save the color image of branchpoints and
trunks. This is the image that is displayed in the output window for
this module.""" % globals(),
)
self.branchpoint_image_name = cps.ImageNameProvider(
"Name the branchpoint image",
"BranchpointImage",
doc="""\
*(Used only if a branchpoint image is to be retained)*
Enter a name for the branchpoint image here. You can then use this image
in a later module, such as **SaveImages**.""",
)
self.wants_to_fill_holes = cps.Binary(
"Fill small holes?",
True,
doc="""\
The algorithm reskeletonizes the image and this can leave artifacts
caused by small holes in the image prior to skeletonizing. These holes
result in false trunks and branchpoints. Select "*Yes*" to fill in
these small holes prior to skeletonizing.""" % globals(),
)
self.maximum_hole_size = cps.Integer(
"Maximum hole size",
10,
minval=1,
doc="""\
*(Used only when filling small holes)*
This is the area of the largest hole to fill, measured in pixels. The
algorithm will fill in any hole whose area is this size or smaller.""",
)
self.wants_objskeleton_graph = cps.Binary(
"Export the skeleton graph relationships?",
False,
doc="""\
Select "*Yes*" to produce an edge file and a vertex file that gives the
relationships between vertices (trunks, branchpoints and endpoints).""" %
globals(),
)
self.intensity_image_name = cps.ImageNameSubscriber(
"Intensity image",
"None",
doc="""\
Select the image to be used to calculate
the total intensity along the edges between the vertices (trunks, branchpoints, and endpoints).""",
)
self.directory = cps.DirectoryPath(
"File output directory",
doc=
"Select the directory you want to save the graph relationships to.",
dir_choices=[
cpprefs.DEFAULT_OUTPUT_FOLDER_NAME,
cpprefs.DEFAULT_INPUT_FOLDER_NAME,
cpprefs.ABSOLUTE_FOLDER_NAME,
cpprefs.DEFAULT_OUTPUT_SUBFOLDER_NAME,
cpprefs.DEFAULT_INPUT_SUBFOLDER_NAME,
],
)
self.directory.dir_choice = cpprefs.DEFAULT_OUTPUT_FOLDER_NAME
self.vertex_file_name = cps.Text(
"Vertex file name",
"vertices.csv",
doc="""\
*(Used only when exporting graph relationships)*
Enter the name of the file that will hold the edge information. You can
use metadata tags in the file name.
Each line of the file is a row of comma-separated values. The first
row is the header; this names the file’s columns. Each subsequent row
represents a vertex in the skeleton graph: either a trunk, a
branchpoint or an endpoint. The file has the following columns:
- *image\_number:* The image number of the associated image.
- *vertex\_number:* The number of the vertex within the image.
- *i:* The I coordinate of the vertex.
- *j:* The J coordinate of the vertex.
- *label:* The label of the seed object associated with the vertex.
- *kind:* The vertex type, with the following choices:
- **T:** Trunk
- **B:** Branchpoint
- **E:** Endpoint
""",
)
self.edge_file_name = cps.Text(
"Edge file name",
"edges.csv",
doc="""\
*(Used only when exporting graph relationships)*
Enter the name of the file that will hold the edge information. You can
use metadata tags in the file name. Each line of the file is a row of
comma-separated values. The first row is the header; this names the
file’s columns. Each subsequent row represents an edge or connection
between two vertices (including between a vertex and itself for certain
loops). Note that vertices include trunks, branchpoints, and endpoints.
The file has the following columns:
- *image\_number:* The image number of the associated image.
- *v1:* The zero-based index into the vertex table of the first vertex
in the edge.
- *v2:* The zero-based index into the vertex table of the second vertex
in the edge.
- *length:* The number of pixels in the path connecting the two
vertices, including both vertex pixels.
- *total\_intensity:* The sum of the intensities of the pixels in the
edge, including both vertex pixel intensities.
""",
)
def create_settings(self):
self.input_image = cps.ImageNameSubscriber(
"Select an input image",
"None",
doc=
"""Select the image to be tiled. Additional images within the cycle can be
added later by choosing the "*%(T_ACROSS_CYCLES)s*" option below.
""" % globals(),
)
self.output_image = cps.ImageNameProvider(
"Name the output image",
"TiledImage",
doc="""Enter a name for the final tiled image.""",
)
self.additional_images = []
self.add_button = cps.DoSomething(
"",
"Add another image",
self.add_image,
doc="""Add images from other channels to perform similar tiling""",
)
self.tile_method = cps.Choice(
"Tile assembly method",
T_ALL,
doc="""\
This setting controls the method by which the final tiled image is
assembled:
- *%(T_WITHIN_CYCLES)s:* If you have loaded more than one image for
each cycle using modules upstream in the pipeline, the images can be
tiled. For example, you may tile three different channels (OrigRed,
OrigBlue, and OrigGreen), and a new tiled image will be created for
every image cycle.
- *%(T_ACROSS_CYCLES)s:* If you want to tile images from multiple
cycles together, select this option. For example, you may tile all
the images of the same type (e.g., OrigBlue) across all fields of
view in your experiment, which will result in one final tiled image
when processing is complete.
""" % globals(),
)
self.rows = cps.Integer(
"Final number of rows",
8,
doc="""\
Specify the number of rows would you like to have in the tiled image.
For example, if you want to show your images in a 96-well format, enter
8.
*Special cases:* Let *M* be the total number of slots for images (i.e,
number of rows x number of columns) and *N* be the number of actual
images.
- If *M* > *N*, blanks will be used for the empty slots.
- If the *M* < *N*, an error will occur since there are not enough
image slots. Check “Automatically calculate number of rows?” to avoid
this error.
""",
)
self.columns = cps.Integer(
"Final number of columns",
12,
doc="""\
Specify the number of columns you like to have in the tiled image. For
example, if you want to show your images in a 96-well format, enter 12.
*Special cases:* Let *M* be the total number of slots for images (i.e,
number of rows x number of columns) and *N* be the number of actual
images.
- If *M* > *N*, blanks will be used for the empty slots.
- If the *M* < *N*, an error will occur since there are not enough
image slots. Check “Automatically calculate number of columns?” to
avoid this error.
""",
)
self.place_first = cps.Choice(
"Image corner to begin tiling",
P_ALL,
doc=
"""Where do you want the first image to be placed? Begin in the upper
left-hand corner for a typical multi-well plate format where the first image is A01.
""",
)
self.tile_style = cps.Choice(
"Direction to begin tiling",
S_ALL,
doc=
"""This setting specifies the order that the images are to be arranged. For example, if
your images are named A01, A02, etc, enter "*%(S_ROW)s*".
""" % globals(),
)
self.meander = cps.Binary(
"Use meander mode?",
False,
doc="""\
Select "*Yes*" to tile adjacent images in one direction, then the next
row/column is tiled in the opposite direction. Some microscopes capture
images in this fashion. The default mode is “comb”, or “typewriter”
mode; in this mode, when one row is completely tiled in one direction,
the next row starts near where the first row started and tiles again in
the same direction.
""" % globals(),
)
self.wants_automatic_rows = cps.Binary(
"Automatically calculate number of rows?",
False,
doc="""\
**Tile** can automatically calculate the number of rows in the grid
based on the number of image cycles that will be processed. Select
"*Yes*" to create a grid that has the number of columns that you
entered and enough rows to display all of your images. Select "*No*"
to specify the number of rows.
If you check both automatic rows and automatic columns, **Tile** will
create a grid that has roughly the same number of rows and columns.
""" % globals(),
)
self.wants_automatic_columns = cps.Binary(
"Automatically calculate number of columns?",
False,
doc="""\
**Tile** can automatically calculate the number of columns in the grid
from the number of image cycles that will be processed. Select "*Yes*"
to create a grid that has the number of rows that you entered and enough
columns to display all of your images. Select "*No*" to specify the
number of rows.
If you check both automatic rows and automatic columns, **Tile** will
create a grid that has roughly the same number of rows and columns.
""" % globals(),
)
