diff --git a/src/openflexure_microscope_server/background_detect.py b/src/openflexure_microscope_server/background_detect.py index 5438b761..23dc8576 100644 --- a/src/openflexure_microscope_server/background_detect.py +++ b/src/openflexure_microscope_server/background_detect.py @@ -207,11 +207,6 @@ class ColourChannelDetectLUV(BackgroundDetectAlgorithm): The image should be in LUV format, the output will be binary with the same shape in the first two dimensions. """ - if not self.background_data: - raise MissingBackgroundDataError( - "Background is not set: you need to calibrate background detection." - ) - # The ``[1:]`` selects only the U and V channels of the image. # Only U and V are used as brightness (L) often changes as # the height of the sample changes. @@ -236,6 +231,10 @@ class ColourChannelDetectLUV(BackgroundDetectAlgorithm): :returns: A value (between 0 and 100) is the percentage of the image that is sample. """ + if not self.background_data: + raise MissingBackgroundDataError( + "Background is not set: you need to calibrate background detection." + ) image_luv = cv2.cvtColor(image, cv2.COLOR_RGB2LUV) mask = self.background_mask(image_luv) @@ -302,6 +301,10 @@ class ChannelDeviationLUV(BackgroundDetectAlgorithm): :returns: A value (between 0 and 100) is the percentage of the image that is sample. """ + if not self.background_data: + raise MissingBackgroundDataError( + "Background is not set: you need to calibrate background detection." + ) image_luv = cv2.cvtColor(image, cv2.COLOR_RGB2LUV) stds = _chunked_stds(image_luv, 8, 8) @@ -335,7 +338,6 @@ class ChannelDeviationLUV(BackgroundDetectAlgorithm): def set_background(self, image: np.ndarray) -> None: """Use the input image to update the background distributions.""" image_luv = cv2.cvtColor(image, cv2.COLOR_RGB2LUV) - mu = np.zeros(3) c_stds = _chunked_stds(image_luv, 8, 8) channel_blank = np.all(c_stds == 0, axis=(0, 1)) diff --git a/tests/test_background_detectors.py b/tests/test_background_detectors.py index 956a96e9..fbcaf0a3 100644 --- a/tests/test_background_detectors.py +++ b/tests/test_background_detectors.py @@ -15,6 +15,9 @@ from openflexure_microscope_server.background_detect import ( ChannelDistributions, ColourChannelDetectSettings, ColourChannelDetectLUV, + _chunked_stds, + ChannelDeviationLUV, + ChannelBlankError, ) RNG = np.random.default_rng() @@ -181,3 +184,140 @@ def test_colour_channel_luv_load_bad_data(): cc_luv.settings = WrongModel() with pytest.raises(TypeError): cc_luv.background_data = WrongModel() + + +def create_patchwork_image(magnitude=3, blank_channels=None): + """Create a patchwork image, with known stds per chunk. + + :return: The image, and the (8,8,3) array of stds + """ + if blank_channels is None: + blank_channels = [] + n_rows = 8 + n_cols = 8 + chunk_h = 10 + chunk_w = 10 + + # Precompute chunk stds and construct the final image + expected_stds = np.zeros((n_rows, n_cols, 3), dtype=float) + img = np.zeros((n_rows * chunk_h, n_cols * chunk_w, 3), dtype=np.uint8) + + for i in range(n_rows): + for j in range(n_cols): + for channel in range(3): + if channel in blank_channels: + chunk = np.zeros((chunk_h, chunk_w), dtype=np.uint8) + else: + chunk = 9.8 * np.ones((chunk_h, chunk_w)) + chunk += RNG.normal(scale=magnitude, size=(chunk_h, chunk_w)) + chunk = chunk.astype(np.uint8) + + # Store its std + expected_stds[i, j, channel] = np.std(chunk) + + # Insert chunk into the final large image + y0, y1 = i * chunk_h, (i + 1) * chunk_h + x0, x1 = j * chunk_w, (j + 1) * chunk_w + img[y0:y1, x0:x1, channel] = chunk + return img, expected_stds + + +def test_chunked_stds_with_precomputed_chunk_stds(): + """Test _chunked_stds returns the answer calculated when making a patchwork image.""" + img, expected_stds = create_patchwork_image() + + # Run the function under test + result = _chunked_stds(img, n_rows=8, n_cols=8) + + # Compare + np.testing.assert_allclose(result, expected_stds, rtol=1e-6, atol=1e-12) + + +def test_channel_deviation_luv_set_background(mocker): + """Test set_background takes the median of each channel, and errors for blank channels.""" + cd_luv = ChannelDeviationLUV() + + # Patch RGB to LUV so or we don't know what the STDs should be + mocker.patch("cv2.cvtColor", side_effect=lambda img, _method: img) + + for magnitude in [0.2, 1, 10]: + # Create an image and set it as background + img, expected_stds = create_patchwork_image(magnitude=magnitude) + cd_luv.set_background(img) + + # Do a somewhat verbose checking for clarity + for channel in range(3): + # Saved std + channel_std = cd_luv.background_data.standard_deviations[channel] + # Expected median + channel_median = np.median(expected_stds[:, :, channel]) + # If the median is above the minimum allowed then it should be returned + if channel_median > cd_luv.min_stds[channel]: + assert np.isclose(channel_std, channel_median, rtol=1e-6, atol=1e-12) + else: + # If not the minimum is returned. + assert channel_std == cd_luv.min_stds[channel] + + # Also check that if channels are blank then an error is thrown + img, _expected_stds = create_patchwork_image(magnitude=1, blank_channels=[1, 2]) + with pytest.raises(ChannelBlankError): + cd_luv.set_background(img) + + +def test_channel_deviation_luv_image_is_sample(background_image, mocker): + """Check image_is_sample reports the result from get_sample_coverage.""" + cd_luv = ChannelDeviationLUV() + + # No background data so it is not ready and will error if image_is_sample is called. + assert not cd_luv.status.ready + with pytest.raises(MissingBackgroundDataError): + cd_luv.image_is_sample(background_image) + + cd_luv.settings.min_sample_coverage = 20 + cd_luv.get_sample_coverage = mocker.Mock(return_value=10) + is_sample, message = cd_luv.image_is_sample(background_image) + assert not is_sample + assert message == r"only 10.0% sample" + + # Reduce the min coverage + cd_luv.settings.min_sample_coverage = 9 + + is_sample, message = cd_luv.image_is_sample(background_image) + assert is_sample + assert message == r"10.0% sample" + + +def test_channel_deviation_luv_get_sample_coverage(background_image, mocker): + """Check _get_sample_coverage returns the values expected.""" + cd_luv = ChannelDeviationLUV() + + # Create fake chunked STD data where each channel os the numbers 0 -> 31.5 in 0.5 + # steps + grid = np.arange(0, 32, 0.5).reshape(8, 8) + fake_stds = np.stack([grid, grid, grid], axis=-1) + mocker.patch( + "openflexure_microscope_server.background_detect._chunked_stds", + return_value=fake_stds, + ) + + # Create fake background + cd_luv.background_data = ChannelDistributions( + means=[0, 0, 0], standard_deviations=[1.1, 1.1, 1.1] + ) + # Get sample coverage with channel tolerance of 7. Checking each channel for the + # numbers below 7.7. There are 16 out of 64. So 75% should be sample + cd_luv.settings.channel_tolerance = 7 + assert cd_luv.get_sample_coverage(background_image) == 75 + # This is unchanged if two channels have larger background values. + cd_luv.background_data = ChannelDistributions( + means=[0, 0, 0], standard_deviations=[1.6, 1.6, 1.1] + ) + assert cd_luv.get_sample_coverage(background_image) == 75 + # This is but increases if any channels has a lower background value. + cd_luv.background_data = ChannelDistributions( + means=[0, 0, 0], standard_deviations=[1.6, 0.6, 1.1] + ) + assert cd_luv.get_sample_coverage(background_image) == 85.9375 + # Returns to 75% if that channel is empty + fake_stds[:, :, 1] = 0 + assert cd_luv.get_sample_coverage(background_image) == 75