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

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_preprocessing.py

@@ -0,0 +1,37 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+from celldetective.preprocessing import fit_background_model, field_correction
+
+import matplotlib.pyplot as plt
+
+class TestFitPlane(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		a = 5.
+		self.img = np.full((100,100),5.0)
+		self.img_with_cell = self.img.copy()
+		self.img_with_cell[:10,:10] = 25.0
+
+	def test_plane_is_well_fit(self):
+		mat = np.array(fit_background_model(self.img, cell_masks=None, model='plane', edge_exclusion=None))
+		self.assertTrue(np.allclose(self.img, mat))
+
+	def test_plane_is_well_fit_and_applied_with_division(self):
+		result = field_correction(self.img, threshold_on_std=1.0E05, operation='divide', model='plane', clip=False, return_bg=False, activation_protocol=[])
+		self.assertTrue(np.allclose(result, np.full((100,100), 1.0)))
+
+	def test_plane_is_well_fit_and_applied_with_subtraction(self):
+		result = field_correction(self.img, threshold_on_std=1.0E05, operation='subtract', model='plane', clip=False, return_bg=False, activation_protocol=[])
+		self.assertTrue(np.allclose(result, np.zeros((100,100))))
+
+	def test_plane_is_well_fit_with_cell(self):
+		cell_masks = np.zeros_like(self.img)
+		cell_masks[:10,:10] = 1.0
+		mat = np.array(fit_background_model(self.img, cell_masks=cell_masks, model='plane', edge_exclusion=None))
+		self.assertTrue(np.allclose(self.img, mat))
+
+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()

tests/test_tracking.py

@@ -0,0 +1,164 @@
+import unittest
+import numpy as np
+import pandas as pd
+from celldetective.tracking import filter_by_endpoints, extrapolate_tracks, filter_by_tracklength, interpolate_time_gaps
+
+class TestTrackFilteringByEndpoint(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.tracks = pd.DataFrame([{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 30, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 40, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 10, "POSITION_Y": 25}
+
+									])
+
+	def test_filter_not_in_last(self):
+		self.filtered_tracks = filter_by_endpoints(self.tracks, remove_not_in_first=False, remove_not_in_last=True)
+		track_ids = list(self.filtered_tracks['TRACK_ID'].unique())
+		self.assertEqual(track_ids,[0.])
+
+	def test_filter_not_in_first(self):
+		self.filtered_tracks = filter_by_endpoints(self.tracks, remove_not_in_first=True, remove_not_in_last=False)
+		track_ids = list(self.filtered_tracks['TRACK_ID'].unique())
+		self.assertEqual(track_ids,[0.,2.])
+
+	def test_no_filter_does_nothing(self):
+		self.filtered_tracks = filter_by_endpoints(self.tracks, remove_not_in_first=False, remove_not_in_last=False)
+		track_ids = list(self.filtered_tracks['TRACK_ID'].unique())		
+		self.assertEqual(track_ids,list(self.tracks['TRACK_ID'].unique()))
+
+
+class TestTrackFilteringByLength(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.tracks = pd.DataFrame([{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 30, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 40, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 10, "POSITION_Y": 25}
+									])
+
+	def test_filter_by_tracklength_of_zero(self):
+		self.filtered_tracks = filter_by_tracklength(self.tracks, minimum_tracklength=0)
+		track_ids = list(self.filtered_tracks['TRACK_ID'].unique())
+		self.assertEqual(track_ids,[0.,1.,2.])
+
+	def test_filter_by_tracklength_of_three(self):
+		self.filtered_tracks = filter_by_tracklength(self.tracks, minimum_tracklength=3)
+		track_ids = list(self.filtered_tracks['TRACK_ID'].unique())
+		self.assertEqual(track_ids,[0.])
+
+
+class TestTrackInterpolation(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+
+		self.tracks = pd.DataFrame([{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									#{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									#{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+		self.tracks_real_intep = pd.DataFrame([{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+
+
+	def test_interpolate_tracks_as_expected(self):
+		self.interpolated_tracks = interpolate_time_gaps(self.tracks)
+		self.assertTrue(np.array_equal(self.interpolated_tracks.to_numpy(), self.tracks_real_intep.to_numpy(), equal_nan=True))
+
+class TestTrackExtrapolation(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+
+		self.tracks = pd.DataFrame([{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+		self.tracks_pre_extrapol = pd.DataFrame([
+									{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 0, "POSITION_X": 5, "POSITION_Y": 20},									
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+		self.tracks_post_extrapol = pd.DataFrame([
+									{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 1., "FRAME": 3, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 3, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+
+		self.tracks_full_extrapol = pd.DataFrame([
+									{"TRACK_ID": 0., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 15},
+									{"TRACK_ID": 0., "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+									{"TRACK_ID": 0., "FRAME": 2, "POSITION_X": 20, "POSITION_Y": 5},
+									{"TRACK_ID": 0., "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+									{"TRACK_ID": 1., "FRAME": 0, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+									{"TRACK_ID": 1., "FRAME": 2, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 1., "FRAME": 3, "POSITION_X": 10, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 25},				
+									{"TRACK_ID": 2., "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 2, "POSITION_X": 0, "POSITION_Y": 25},
+									{"TRACK_ID": 2., "FRAME": 3, "POSITION_X": 0, "POSITION_Y": 25}
+									])
+
+
+	def test_pre_extrapolate(self):
+		self.extrapolated_tracks = extrapolate_tracks(self.tracks,post=False, pre=True)
+		self.assertTrue(np.array_equal(self.extrapolated_tracks.to_numpy(), self.tracks_pre_extrapol.to_numpy(), equal_nan=True))
+
+	def test_post_extrapolate(self):
+		self.extrapolated_tracks = extrapolate_tracks(self.tracks,post=True, pre=False)
+		self.assertTrue(np.array_equal(self.extrapolated_tracks.to_numpy(), self.tracks_post_extrapol.to_numpy(), equal_nan=True))
+
+	def test_full_extrapolate(self):
+		self.extrapolated_tracks = extrapolate_tracks(self.tracks,post=True, pre=True)
+		self.assertTrue(np.array_equal(self.extrapolated_tracks.to_numpy(), self.tracks_full_extrapol.to_numpy(), equal_nan=True))
+
+
+if __name__=="__main__":
+	unittest.main()

tests/test_utils.py

@@ -0,0 +1,118 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+from celldetective.utils import create_patch_mask, remove_redundant_features, _extract_channel_indices, _get_img_num_per_channel, split_by_ratio,extract_experiment_channels, estimate_unreliable_edge, unpad, mask_edges
+
+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]))
+
+class TestUnpad(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.array = np.array([[0,0,0],
+							  [0,1,0],
+							  [0,0,0]])
+
+	def test_unpad(self):
+		expected_unpad_array = np.array([[1]])
+		test_array = unpad(self.array, 1)
+		self.assertTrue(np.array_equal(test_array, expected_unpad_array))
+
+class TestMaskEdge(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.binary_mask = np.array([[1, 1, 1, 1, 1],
+									 [1, 1, 1, 1, 1],
+									 [1, 1, 1, 1, 1],
+									 [1, 1, 1, 1, 1],
+									 [1, 1, 1, 1, 1]])
+
+	def test_mask_edge_properly(self):
+		expected_output = np.array([[False, False, False, False, False],
+									[False, True, True, True, False],
+									[False, True, True, True, False],
+									[False, True, True, True, False],
+									[False, False, False, False, False]])
+		actual_output = mask_edges(self.binary_mask, 1)
+		self.assertTrue(np.array_equal(actual_output, expected_output))
+
+class TestEstimateFilterEdge(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.protocol1 = [['gauss',2],['std',4]]
+		self.expected1 = 6
+		self.protocol2 = [['gauss',4],['variance','string_arg']]
+		self.expected2 = 4
+
+	def test_edge_is_estimated_properly_with_only_number_arguments(self):
+		self.assertEqual(self.expected1, estimate_unreliable_edge(self.protocol1))
+	
+	def test_edge_is_estimated_properly_with_mixed_arguments(self):
+		self.assertEqual(self.expected2, estimate_unreliable_edge(self.protocol2))
+
+
+if __name__=="__main__":
+	unittest.main()