def create_settings(self):
"""Create the settings & name the module"""
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.divider = Divider(line=False)
self.wants_objects = Binary(
"Measure the intensity only from areas enclosed by objects?",
False,
doc="""\
Select *Yes* to measure only those pixels within an object type you
choose, identified by a prior module. Note that this module will
aggregate intensities across all objects in the image: to measure each
object individually, see **MeasureObjectIntensity** instead.
""",
)
self.objects_list = LabelListSubscriber(
"Select input object sets",
[],
doc=
"""Select the object sets whose intensity you want to measure.""",
)
def create_settings(self):
self.operand_choice = Choice(
"Measure the area occupied by",
[O_BINARY_IMAGE, O_OBJECTS, O_BOTH],
doc="""\
Area occupied can be measured in two ways:
- *{O_BINARY_IMAGE}:* The area occupied by the foreground in a binary (black and white) image.
- *{O_OBJECTS}:* The area occupied by previously-identified objects.
""".format(**{
"O_BINARY_IMAGE": O_BINARY_IMAGE,
"O_OBJECTS": O_OBJECTS
}),
)
self.divider = Divider()
self.images_list = ImageListSubscriber(
"Select binary images to measure",
[],
doc="""*(Used only if ‘{O_BINARY_IMAGE}’ is to be measured)*
These should be binary images created earlier in the pipeline, where you would
like to measure the area occupied by the foreground in the image.
""".format(**{"O_BINARY_IMAGE": O_BINARY_IMAGE}),
)
self.objects_list = LabelListSubscriber(
"Select object sets to measure",
[],
doc="""*(Used only if ‘{O_OBJECTS}’ are to be measured)*
Select the previously identified objects you would like to measure.""".format(
**{"O_OBJECTS": O_OBJECTS}),
)
def create_settings(self):
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.divider = Divider()
self.objects_list = LabelListSubscriber(
"Select objects to measure",
[],
doc=
"""Select the object sets whose intensity you want to measure.""",
)
def create_settings(self):
"""Create the settings & name the module"""
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc="""Select the grayscale images whose intensity you want to measure.""",
)
self.divider = Divider(line=False)
self.wants_objects = Binary(
"Measure the intensity only from areas enclosed by objects?",
False,
doc="""\
Select *Yes* to measure only those pixels within an object type you
choose, identified by a prior module. Note that this module will
aggregate intensities across all objects in the image: to measure each
object individually, see **MeasureObjectIntensity** instead.
""",
)
self.objects_list = LabelListSubscriber(
"Select input object sets",
[],
doc="""Select the object sets whose intensity you want to measure.""",
)
self.wants_percentiles = Binary(
text="Calculate custom percentiles",
value=False,
doc="""Choose whether to enable measurement of custom percentiles.
Note that the Upper and Lower Quartile measurements are automatically calculated by this module,
representing the 25th and 75th percentiles.
""",
)
self.percentiles = Text(
text="Specify percentiles to measure",
value="10,90",
doc="""Specify the percentiles to measure. Values should range from 0-100 inclusive and be whole integers.
Multiple values can be specified by seperating them with a comma,
eg. "10,90" will measure the 10th and 90th percentiles.
""",
)
def create_settings(self):
"""Create the settings for the module at startup and set the module name
The module allows for an unlimited number of measured objects, each
of which has an entry in self.object_groups.
"""
self.objects_list = LabelListSubscriber(
"Select object sets to measure",
[],
doc=
"""Select the object sets whose size and shape you want to measure.""",
)
self.spacer = Divider(line=True)
self.calculate_advanced = Binary(
text="Calculate the advanced features?",
value=False,
doc="""\
Select *{YES}* to calculate additional statistics for object moments
and intertia tensors in **2D mode**. These features should not require much additional time
to calculate, but do add many additional columns to the resulting output
files.
In **3D mode** this setting enables the Solidity measurement, which can be time-consuming
to calculate.""".format(**{"YES": "Yes"}),
)
self.calculate_zernikes = Binary(
text="Calculate the Zernike features?",
value=True,
doc="""\
Select *{YES}* to calculate the Zernike shape features. Because the
first 10 Zernike polynomials (from order 0 to order 9) are calculated,
this operation can be time consuming if the image contains a lot of
objects. Select *{NO}* if you are measuring 3D objects with this
module.""".format(**{
"YES": "Yes",
"NO": "No"
}),
)
def create_settings(self):
"""Create the settings & name the module"""
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.divider = Divider(line=False)
self.wants_objects = Binary(
"Measure the intensity only from areas enclosed by objects?",
False,
doc="""\
Select *Yes* to measure only those pixels within an object type you
choose, identified by a prior module. Note that this module will
aggregate intensities across all objects in the image: to measure each
object individually, see **MeasureObjectIntensity** instead.
""",
)
self.objects_list = LabelListSubscriber(
"Select input object sets",
[],
doc=
"""Select the object sets whose intensity you want to measure.""",
)
self.nchannels = Integer(
"How many channels does the image have?",
1,
doc="""
Indicate how many planes this image have. This is needed as
the cellprofiler pipeline needs to be independent of the actuall
image data.
""",
)
def create_settings(self):
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.divider = Divider()
self.objects_list = LabelListSubscriber(
"Select objects to measure",
[],
doc=
"""Select the object sets whose intensity you want to measure.""",
)
self.nchannels = Integer(
"How many channels does the image have?",
1,
doc="""
Indicate how many planes this image have. This is needed as
the cellprofiler pipeline needs to be independent of the actuall
image data.
""",
)
def create_settings(self):
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.objects_list = LabelListSubscriber(
"Select objects to measure",
[],
doc="""\
Select the objects whose texture you want to measure. If you only want
to measure the texture for the image overall, you can remove all objects
using the “Remove this object” button.
Objects specified here will have their texture measured against *all*
images specified above, which may lead to image-object combinations that
are unnecessary. If you do not want this behavior, use multiple
**MeasureTexture** modules to specify the particular image-object
measures that you want.
""",
)
self.gray_levels = Integer(
"Enter how many gray levels to measure the texture at",
256,
2,
256,
doc="""\
Enter the number of gray levels (ie, total possible values of intensity)
you want to measure texture at. Measuring at more levels gives you
_potentially_ more detailed information about your image, but at the cost
of somewhat decreased processing speed.
Before processing, your image will be rescaled from its current pixel values
to 0 - [gray levels - 1]. The texture features will then be calculated.
In all CellProfiler 2 versions, this value was fixed at 8; in all
CellProfiler 3 versions it was fixed at 256. The minimum number of levels is
2, the maximum is 256.
""",
)
self.scale_groups = []
self.scale_count = HiddenCount(self.scale_groups)
self.image_divider = Divider()
self.object_divider = Divider()
self.add_scale(removable=False)
self.add_scales = DoSomething(
callback=self.add_scale,
label="Add another scale",
text="",
doc="""\
Add an additional texture scale to measure. Useful when you
want to measure texture features of different sizes.
""",
)
self.images_or_objects = Choice(
"Measure whole images or objects?",
[IO_IMAGES, IO_OBJECTS, IO_BOTH],
value=IO_BOTH,
doc="""\
This setting determines whether the module computes image-wide
measurements, per-object measurements or both.
- *{IO_IMAGES}:* Select if you only want to measure the texture
across entire images.
- *{IO_OBJECTS}:* Select if you want to measure the texture
on a per-object basis only.
- *{IO_BOTH}:* Select to make both image and object measurements.
""".format(
**{
"IO_IMAGES": IO_IMAGES,
"IO_OBJECTS": IO_OBJECTS,
"IO_BOTH": IO_BOTH
}),
)
def create_settings(self):
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc=
"""Select the grayscale images whose intensity you want to measure.""",
)
self.objects_list = LabelListSubscriber(
"Select objects to measure",
[],
doc="""\
Select the objects whose texture you want to measure. If you only want
to measure the texture for the image overall, you can remove all objects
using the “Remove this object” button.
Objects specified here will have their texture measured against *all*
images specified above, which may lead to image-object combinations that
are unnecessary. If you do not want this behavior, use multiple
**MeasureTexture** modules to specify the particular image-object
measures that you want.
""",
)
self.scale_groups = []
self.scale_count = HiddenCount(self.scale_groups)
self.image_divider = Divider()
self.object_divider = Divider()
self.add_scale(removable=False)
self.add_scales = DoSomething(
callback=self.add_scale,
label="Add another scale",
text="",
doc="""\
Add an additional texture scale to measure. Useful when you
want to measure texture features of different sizes.
""",
)
self.images_or_objects = Choice(
"Measure whole images or objects?",
[IO_IMAGES, IO_OBJECTS, IO_BOTH],
value=IO_BOTH,
doc="""\
This setting determines whether the module computes image-wide
measurements, per-object measurements or both.
- *{IO_IMAGES}:* Select if you only want to measure the texture
across entire images.
- *{IO_OBJECTS}:* Select if you want to measure the texture
on a per-object basis only.
- *{IO_BOTH}:* Select to make both image and object measurements.
""".format(
**{
"IO_IMAGES": IO_IMAGES,
"IO_OBJECTS": IO_OBJECTS,
"IO_BOTH": IO_BOTH
}),
)
def test_set_object_list(self):
s = LabelListSubscriber("foo")
s.value = "SampleName3, SampleName4"
self.assertEqual(s.value_text, "SampleName3, SampleName4")
self.assertEqual(s.value, ["SampleName3", "SampleName4"])
def test_load_object_list_multiple(self):
s = LabelListSubscriber("foo", value="SampleName1, SampleName2")
self.assertEqual(s.value_text, "SampleName1, SampleName2")
self.assertEqual(s.value, ["SampleName1", "SampleName2"])
def test_load_object_list_single(self):
s = LabelListSubscriber("foo", value="SampleName")
self.assertEqual(s.value_text, "SampleName")
self.assertEqual(s.value, ["SampleName"])
def test_load_object_list_empty(self):
s = LabelListSubscriber("foo")
self.assertEqual(s.value_text, "")
self.assertEqual(s.value, [])
def create_settings(self):
self.images_list = ImageListSubscriber(
"Select images to measure",
[],
doc="""Select images in which to measure the granularity.""",
)
self.divider_top = Divider(line=True)
self.wants_objects = Binary(
"Measure within objects?",
False,
doc="""\
Press this button to capture 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.""",
)
self.objects_list = LabelListSubscriber(
"Select objects to measure",
[],
doc="""\
*(Used only when "Measure within objects" is enabled)*
Select the objects within which granularity will be measured.""",
)
self.divider_bottom = Divider(line=True)
self.subsample_size = Float(
"Subsampling factor for granularity measurements",
0.25,
minval=numpy.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.
Downsampling 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""",
)
self.image_sample_size = Float(
"Subsampling factor for background reduction",
0.25,
minval=numpy.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.""",
)
self.element_size = 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.""",
)
self.granular_spectrum_length = 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.""",
)