celldetective 1.0.2.post1__py3-none-any.whl → 1.1.0__py3-none-any.whl

tests/test_events.py

@@ -0,0 +1,28 @@
+import unittest
+from celldetective.events import switch_to_events
+
+class TestEventSwitch(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.classes = [0,0,1,1,2]
+		self.event_times = [5.,8.5,-1,-1,-1]
+		self.max_times = [10,10,10,10,10]
+		self.origin_times = [0,3,2,1,0]
+
+		self.expected_events = [1,1,0,0]
+		self.expected_times = [5.,5.5,8,9]
+
+	def test_expected_events(self):
+		events, times = switch_to_events(
+										self.classes,
+										self.event_times,
+										self.max_times,
+										self.origin_times
+										)
+		self.assertEqual(events, self.expected_events)
+		self.assertEqual(times, self.expected_times)
+
+
+if __name__=="__main__":
+	unittest.main()

tests/test_filters.py

@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from celldetective.filters import gauss_filter, abs_filter
+
+
+class TestFilters(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.img = np.ones((256,256),dtype=int)
+		self.img[100:110,100:110] = 0
+		self.gauss_sigma = 1.6
+
+	def test_gauss_filter_is_float(self):
+		self.assertIsInstance(gauss_filter(self.img, self.gauss_sigma)[0,0], float)
+	
+	def test_gauss_filter_has_same_shape(self):
+		self.assertEqual(gauss_filter(self.img, self.gauss_sigma).shape, self.img.shape)
+
+	def test_abs_filter_is_positive(self):
+		self.assertTrue(np.all(abs_filter(self.img) >= 0.))
+
+if __name__=="__main__":
+	unittest.main()

tests/test_io.py

@@ -0,0 +1,70 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+# class TestPatchMask(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.radius = 3
+
+# 	def test_correct_shape(self):
+# 		self.patch = create_patch_mask(self.radius, self.radius)
+# 		self.assertEqual(self.patch.shape,(3,3))
+
+# 	def test_correct_ring(self):
+# 		self.patch = create_patch_mask(5, 5,radius=[1,2])
+# 		self.assertFalse(self.patch[2,2])
+
+# class TestRemoveRedundantFeatures(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.list_a = ['feat1','feat2','feat3','feat4','intensity_mean']
+# 		self.list_b = ['feat5','feat2','feat1','feat6','test_channel_mean']
+# 		self.expected = ['feat3','feat4']
+
+# 	def test_remove_red_features(self):
+# 		self.assertEqual(remove_redundant_features(self.list_a, self.list_b, channel_names=['test_channel']), self.expected)
+
+
+# class TestExtractChannelIndices(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels = ['ch1','ch2','ch3','ch4']
+# 		self.required_channels = ['ch4','ch2']
+# 		self.expected_indices = [3,1]
+
+# 	def test_extracted_channels_are_correct(self):
+# 		self.assertEqual(list(_extract_channel_indices(self.channels, self.required_channels)), self.expected_indices)
+
+
+# class TestImgIndexPerChannel(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels_indices = [1]
+# 		self.len_movie = 5
+# 		self.nbr_channels = 3
+# 		self.expected_indices = [1,4,7,10,13]
+
+# 	def test_index_sequence_is_correct(self):
+# 		self.assertEqual(list(_get_img_num_per_channel(self.channels_indices, self.len_movie, self.nbr_channels)[0]), self.expected_indices)
+
+
+# class TestSplitArrayByRatio(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.array_length = 100
+# 		self.array = np.ones(self.array_length)
+
+# 	def test_ratio_split_is_correct(self):
+# 		split_array = split_by_ratio(self.array,0.5,0.25,0.1)
+# 		self.assertTrue(np.all([len(split_array[0])==50, len(split_array[1])==25, len(split_array[2])==10]))
+
+
+# if __name__=="__main__":
+# 	unittest.main()

tests/test_measure.py

@@ -0,0 +1,141 @@
+import unittest
+import pandas as pd
+import numpy as np
+from celldetective.measure import measure_features, measure_isotropic_intensity, drop_tonal_features
+
+class TestFeatureMeasurement(unittest.TestCase):
+
+	"""
+	To do: test spot detection, fluo normalization and peripheral measurements
+	"""
+
+	@classmethod
+	def setUpClass(self):
+
+		# Simple mock data, 100px*100px, one channel, value is one, uniform
+		# Two objects in labels map
+
+		self.frame = np.ones((100,100,1), dtype=float)
+		self.labels = np.zeros((100,100), dtype=int)
+		self.labels[50:55,50:55] = 1
+		self.labels[0:10,0:10] = 2
+
+		self.feature_measurements = measure_features(
+												self.frame, 
+												self.labels, 
+												features=['intensity_mean','area',],
+												channels=['test_channel']
+												)
+
+		self.feature_measurements_no_image = measure_features(
+															None, 
+															self.labels, 
+															features=['intensity_mean','area',],
+															channels=None
+															)
+
+		self.feature_measurements_no_features = measure_features(
+															self.frame, 
+															self.labels, 
+															features=None,
+															channels=['test_channel'],
+															)
+
+	# With image
+	def test_measure_yields_table(self):
+		self.assertIsInstance(self.feature_measurements, pd.DataFrame)
+
+	def test_two_objects(self):
+		self.assertEqual(len(self.feature_measurements),2)
+
+	def test_channel_named_correctly(self):
+		self.assertIn('test_channel_mean',list(self.feature_measurements.columns))
+
+	def test_intensity_is_one(self):
+		self.assertTrue(np.all([v==1.0 for v in self.feature_measurements['test_channel_mean'].values]))
+
+	def test_area_first_is_twenty_five(self):
+		self.assertEqual(self.feature_measurements['area'].values[0],25)
+
+	def test_area_second_is_hundred(self):
+		self.assertEqual(self.feature_measurements['area'].values[1],100)
+
+	# Without image
+	def test_measure_yields_table(self):
+		self.assertIsInstance(self.feature_measurements_no_image, pd.DataFrame)
+
+	def test_two_objects(self):
+		self.assertEqual(len(self.feature_measurements_no_image),2)
+
+	def test_channel_not_in_table(self):
+		self.assertNotIn('test_channel_mean',list(self.feature_measurements_no_image.columns))
+
+	# With no features
+	def test_only_one_measurement(self):
+		cols = list(self.feature_measurements_no_features.columns)
+		assert 'class_id' in cols and len(cols)==1
+
+
+class TestIsotropicMeasurement(unittest.TestCase):
+
+	"""
+	
+	Test that isotropic intensity measurements behave as expected on fake image
+
+	"""
+
+	@classmethod
+	def setUpClass(self):
+
+		# Simple mock data, 100px*100px, one channel, value is one
+		# Square (21*21px) of value 0. in middle
+		# Two objects in labels map
+
+		self.frame = np.ones((100,100,1), dtype=float)
+		self.frame[40:61,40:61,0] = 0.
+		self.positions = pd.DataFrame([{'TRACK_ID': 0, 'POSITION_X': 50, 'POSITION_Y': 50, 'FRAME': 0, 'class_id': 0}])
+		
+		self.inner_radius = 9
+		self.upper_radius = 20
+		self.safe_upper_radius = int(21//2*np.sqrt(2))+2
+
+		self.iso_measurements = measure_isotropic_intensity(self.positions,
+															self.frame,
+															channels=['test_channel'],
+															intensity_measurement_radii=[self.inner_radius, self.upper_radius],
+															operations = ['mean'],
+															)
+		self.iso_measurements_ring = measure_isotropic_intensity(
+															self.positions,
+															self.frame,
+															channels=['test_channel'],
+															intensity_measurement_radii=[[self.safe_upper_radius, self.safe_upper_radius+3]],
+															operations = ['mean'],
+															)
+
+
+	def test_measure_yields_table(self):
+	 	self.assertIsInstance(self.iso_measurements, pd.DataFrame)
+
+	def test_intensity_zero_in_small_circle(self):
+		self.assertEqual(self.iso_measurements[f'test_channel_circle_{self.inner_radius}_mean'].values[0],0.)
+
+	def test_intensity_greater_than_zero_in_intermediate_circle(self):
+		self.assertGreater(self.iso_measurements[f'test_channel_circle_{self.upper_radius}_mean'].values[0],0.)
+	
+	def test_ring_measurement_avoids_zero(self):
+		self.assertEqual(self.iso_measurements[f'test_channel_ring_{self.safe_upper_radius}_{self.safe_upper_radius+3}_mean'].values[0],1.0)
+
+class TestDropTonal(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.features = ['area', 'intensity_mean', 'intensity_max']
+
+	def test_drop_tonal(self):
+		self.features_processed = drop_tonal_features(self.features)
+		self.assertEqual(self.features_processed,['area'])
+
+
+if __name__=="__main__":
+	unittest.main()

tests/test_neighborhood.py

@@ -0,0 +1,70 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+# class TestPatchMask(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.radius = 3
+
+# 	def test_correct_shape(self):
+# 		self.patch = create_patch_mask(self.radius, self.radius)
+# 		self.assertEqual(self.patch.shape,(3,3))
+
+# 	def test_correct_ring(self):
+# 		self.patch = create_patch_mask(5, 5,radius=[1,2])
+# 		self.assertFalse(self.patch[2,2])
+
+# class TestRemoveRedundantFeatures(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.list_a = ['feat1','feat2','feat3','feat4','intensity_mean']
+# 		self.list_b = ['feat5','feat2','feat1','feat6','test_channel_mean']
+# 		self.expected = ['feat3','feat4']
+
+# 	def test_remove_red_features(self):
+# 		self.assertEqual(remove_redundant_features(self.list_a, self.list_b, channel_names=['test_channel']), self.expected)
+
+
+# class TestExtractChannelIndices(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels = ['ch1','ch2','ch3','ch4']
+# 		self.required_channels = ['ch4','ch2']
+# 		self.expected_indices = [3,1]
+
+# 	def test_extracted_channels_are_correct(self):
+# 		self.assertEqual(list(_extract_channel_indices(self.channels, self.required_channels)), self.expected_indices)
+
+
+# class TestImgIndexPerChannel(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels_indices = [1]
+# 		self.len_movie = 5
+# 		self.nbr_channels = 3
+# 		self.expected_indices = [1,4,7,10,13]
+
+# 	def test_index_sequence_is_correct(self):
+# 		self.assertEqual(list(_get_img_num_per_channel(self.channels_indices, self.len_movie, self.nbr_channels)[0]), self.expected_indices)
+
+
+# class TestSplitArrayByRatio(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.array_length = 100
+# 		self.array = np.ones(self.array_length)
+
+# 	def test_ratio_split_is_correct(self):
+# 		split_array = split_by_ratio(self.array,0.5,0.25,0.1)
+# 		self.assertTrue(np.all([len(split_array[0])==50, len(split_array[1])==25, len(split_array[2])==10]))
+
+
+# if __name__=="__main__":
+# 	unittest.main()

tests/test_segmentation.py

@@ -0,0 +1,93 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import json
+from tifffile import imread
+from celldetective.segmentation import segment, segment_frame_from_thresholds
+from tensorflow.keras.metrics import BinaryIoU
+
+TEST_IMAGE_FILENAME = os.path.join(os.path.dirname(__file__), os.sep.join(['assets','sample.tif']))
+TEST_LABEL_FILENAME = os.path.join(os.path.dirname(__file__), os.sep.join(['assets','sample_labelled.tif']))
+TEST_CONFIG_FILENAME = os.path.join(os.path.dirname(__file__), os.sep.join(['assets','sample.json']))
+
+class TestDLMCF7Segmentation(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.img = imread(TEST_IMAGE_FILENAME)
+		self.label_true = imread(TEST_LABEL_FILENAME)
+		self.stack = np.moveaxis([self.img, self.img, self.img],1,-1)
+		with open(TEST_CONFIG_FILENAME) as config_file:
+			self.config = json.load(config_file)
+		self.channels = self.config['channels']
+		self.spatial_calibration = self.config['spatial_calibration']
+
+	def test_correct_segmentation_with_multimodal_model(self):
+		
+		labels = segment(self.stack, "MCF7_bf_pi_cfse_h", channels=self.channels, spatial_calibration=self.spatial_calibration, view_on_napari=False,
+						use_gpu=False)
+		np.testing.assert_array_equal(labels[0], labels[1])
+
+		self.binary_label_true = self.label_true.copy().astype(float)
+		self.binary_label_true[self.binary_label_true>0] = 1.
+
+		label_binary = labels[0].copy().astype(float)
+		label_binary[label_binary>0] = 1.
+
+		m = BinaryIoU(target_class_ids=[1])
+		m.update_state(self.binary_label_true, label_binary)
+		score = m.result().numpy()
+
+		self.assertGreater(score,0.9)
+
+	def test_correct_segmentation_with_transferred_model(self):
+		
+		labels = segment(self.stack, "MCF7_h_versatile", channels=self.channels, spatial_calibration=self.spatial_calibration, view_on_napari=False,
+			use_gpu=True, time_flat_normalization=False, time_flat_percentiles=(0.0,99.99))
+		np.testing.assert_array_equal(labels[0], labels[1])
+
+		self.binary_label_true = self.label_true.copy().astype(float)
+		self.binary_label_true[self.binary_label_true>0] = 1.
+
+		label_binary = labels[0].copy().astype(float)
+		label_binary[label_binary>0] = 1.
+
+		m = BinaryIoU(target_class_ids=[1])
+		m.update_state(self.binary_label_true, label_binary)
+		score = m.result().numpy()
+
+		self.assertGreater(score,0.9)
+
+
+class TestThresholdMCF7Segmentation(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.img = imread(TEST_IMAGE_FILENAME)
+		self.label_true = imread(TEST_LABEL_FILENAME)
+		with open(TEST_CONFIG_FILENAME) as config_file:
+			self.config = json.load(config_file)
+		self.channels = self.config['channels']
+		self.spatial_calibration = self.config['spatial_calibration']
+
+	def test_correct_segmentation_with_threshold(self):
+		
+		label = segment_frame_from_thresholds(np.moveaxis(self.img,0,-1), target_channel=3, thresholds=[8000,1.0E10], equalize_reference=None,
+								  filters=[['variance',4],['gauss',2]], marker_min_distance=13, marker_footprint_size=34, marker_footprint=None, feature_queries=["area < 80"], channel_names=None)
+		
+		self.binary_label_true = self.label_true.copy().astype(float)
+		self.binary_label_true[self.binary_label_true>0] = 1.
+
+		label_binary = label.copy().astype(float)
+		label_binary[label_binary>0] = 1.
+
+		m = BinaryIoU(target_class_ids=[1])
+		m.update_state(self.binary_label_true, label_binary)
+		score = m.result().numpy()
+
+		self.assertGreater(score,0.7)
+
+
+if __name__=="__main__":
+	unittest.main()

tests/test_signals.py

@@ -0,0 +1,135 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import random
+import pandas as pd
+import shutil
+
+def sigmoid(t,t0,dt,A,offset):
+	return A/(1+np.exp(-(t-t0)/dt)) + offset
+
+def generate_fake_signal_data(n_signals):
+	
+	timeline = np.linspace(0,100,100)
+	amplitudes = list(np.linspace(2000,3000,100))
+	slopes = list(np.linspace(0.5,5,100))
+	means = list(np.linspace(-100,200,100))
+	random_cut = list(np.linspace(25,200,176,dtype=int))
+	noise_levels = list(np.linspace(1,100,100,dtype=int))
+
+	trajectories = []
+	for i in range(n_signals):
+		
+		a = random.sample(amplitudes,k=1)[0]
+		dt = random.sample(slopes,k=1)[0]
+		mu = random.sample(means,k=1)[0]
+		cut = random.sample(random_cut,k=1)[0]
+		n = random.sample(noise_levels,k=1)[0]
+		
+		if mu<=0.:
+			cclass=2
+			t0=-1
+		elif (mu>0)*(mu<=100):
+			cclass=0
+			t0=mu
+		else:
+			cclass=1
+			t0=-1
+		
+		noise = [random.random()*n for i in range(len(timeline))]
+		signal = sigmoid(timeline, mu, dt,a,0)+noise
+		signal = signal[:cut]
+		if mu>=cut:
+			cclass=1
+			t0=-1
+		
+		for j in range(len(signal)):
+			trajectories.append({'TRACK_ID': i, 'POSITION_X': 0., 'POSITION_Y': 0., 'FRAME': j,'signal': signal[j], 't0': t0, 'cclass': cclass})  
+
+	trajectories = pd.DataFrame(trajectories)
+
+	return trajectories
+
+def export_set(trajectories, name='set.npy', output_folder='.'):
+	
+	training_set = []
+	cols = trajectories.columns
+	tracks = np.unique(trajectories["TRACK_ID"].to_numpy())
+
+	for track in tracks:
+		signals = {}
+		for c in cols:
+			signals.update({c: trajectories.loc[trajectories["TRACK_ID"] == track, c].to_numpy()})
+		time_of_interest = trajectories.loc[trajectories["TRACK_ID"] == track, "t0"].to_numpy()[0]
+		cclass = trajectories.loc[trajectories["TRACK_ID"] == track, "cclass"].to_numpy()[0]
+		signals.update({"time_of_interest": time_of_interest, "class": cclass})
+		training_set.append(signals)
+		
+	np.save(os.sep.join([output_folder,name]), training_set)
+
+
+class TestCreateSignalModel(unittest.TestCase):
+
+	def test_create_model(self):
+
+		from celldetective.signals import SignalDetectionModel
+
+		model = SignalDetectionModel(
+									 channel_option=["signal"], 
+									 model_signal_length=128,
+									 n_channels=1,
+									 n_conv=2,
+									 n_classes=3,
+									 dense_collection=512,
+									 dropout_rate=0.1,
+									 label='test',
+									 )
+
+
+class TestTrainSignalModel(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+
+		from celldetective.signals import SignalDetectionModel
+
+		self.trajectories = generate_fake_signal_data(300)
+		if not os.path.exists('temp'):
+			os.mkdir('temp')
+		export_set(self.trajectories, name='set.npy', output_folder='temp')
+		self.model = SignalDetectionModel(
+									 channel_option=["signal"], 
+									 model_signal_length=128,
+									 n_channels=1,
+									 n_conv=2,
+									 n_classes=3,
+									 dense_collection=512,
+									 dropout_rate=0.1,
+									 label='test',
+									 )
+
+	def test_train_signal_model(self):
+
+		self.model.fit_from_directory(
+									 ['temp'],
+									 normalize=True,
+									 normalization_percentile=None,
+									 normalization_values = None,
+									 normalization_clip = None,
+									 channel_option=["signal"],
+									 target_directory='temp',
+									 augment=False,
+									 model_name='None',
+									 validation_split=0.2,
+									 test_split=0.1,
+									 batch_size = 16,
+									 epochs=1,
+									 recompile_pretrained=False,
+									 learning_rate=0.01,
+									 show_plots=False,
+		                        )
+		shutil.rmtree('temp')
+
+if __name__=="__main__":
+	unittest.main()