Updates for TREC pipelines

Changes supporting use of pipelines in trec-adaptive-feedback project:

• generally, accessors' and models' IDs can be set with respective argument
• test client methods now handle response success check and variable parsing
• implemented functional threshold segmentation and (in base.roiset) classification models; threshold is relative to dataset full range (0.0 to 1.0)
• consequently, more tests cover base package without dependency on ilastik
• RoiSet returned by pipelines get IDs and are registered in server session, accesible at respective endpoints
• Pydantic models only used by FastAPI now; underlying model, accessor, and pipeline functions should interact with python objects and parameter dictionaries only
• RoiSet filters also include minimal and diagonal height, width dimension; are applied before time-intensity pixel array operations to increase performance
• performance improvement when passing patch stacks to ilastik pixel classifier
• RoiSet.classify_by can optionally filter by additional classification columns, e.g. to implement intensity gating

tests/test_ilastik/test_ilastik.py

@@ -209,11 +209,11 @@ class TestServerTestCase(conf.TestServerBaseClass):
 
 class TestIlastikOverApi(TestServerTestCase):
     def test_httpexception_if_incorrect_project_file_loaded(self):
-        resp_load = self.assertPutSuccess(
+        self.assertPutFailure(
             'ilastik/seg/load/',
+            500,
             body={'project_file': 'improper.ilp'},
         )
-        self.assertEqual(resp_load.status_code, 500)
 
 
     def test_load_ilastik_pixel_model(self):
@@ -226,21 +226,18 @@ class TestIlastikOverApi(TestServerTestCase):
         return mid
 
     def test_load_another_ilastik_pixel_model(self):
-        model_id = self.test_load_ilastik_pixel_model()
-        resp_list_1st = self.assertGetSuccess('models').json()
-        self.assertEqual(len(resp_list_1st), 1, resp_list_1st)
-        resp_load_2nd = self.assertPutSuccess(
+        self.test_load_ilastik_pixel_model()
+        self.assertEqual(len(self.assertGetSuccess('models')), 1)
+        self.assertPutSuccess(
             'ilastik/seg/load/',
             body={'project_file': str(ilastik_classifiers['px']['path']), 'duplicate': True},
         )
-        resp_list_2nd = self.assertGetSuccess('models').json()
-        self.assertEqual(len(resp_list_2nd), 2, resp_list_2nd)
-        resp_load_3rd = self.assertPutSuccess(
+        self.assertEqual(len(self.assertGetSuccess('models')), 2)
+        self.assertPutSuccess(
             'ilastik/seg/load/',
             body={'project_file': str(ilastik_classifiers['px']['path']), 'duplicate': False},
         )
-        resp_list_3rd = self.assertGetSuccess('models').json()
-        self.assertEqual(len(resp_list_3rd), 2, resp_list_3rd)
+        self.assertEqual(len(self.assertGetSuccess('models')), 2)
 
     def test_load_ilastik_pixel_model_with_params(self):
         params = {
@@ -248,67 +245,55 @@ class TestIlastikOverApi(TestServerTestCase):
             'px_class': 0,
             'px_prob_threshold': 0.5
         }
-        resp_load = self.assertPutSuccess(
+        mid = self.assertPutSuccess(
             'ilastik/seg/load/',
             body=params,
-        )
-        self.assertEqual(resp_load.status_code, 200, resp_load.json())
-        model_id = resp_load.json()['model_id']
-        mods = self.assertGetSuccess('models').json()
+        )['model_id']
+        mods = self.assertGetSuccess('models')
         self.assertEqual(len(mods), 1)
-        self.assertEqual(mods[model_id]['params']['px_prob_threshold'], 0.5)
+        self.assertEqual(mods[mid]['params']['px_prob_threshold'], 0.5)
 
 
     def test_load_ilastik_pxmap_to_obj_model(self):
-        resp_load = self.assertPutSuccess(
+        mid = self.assertPutSuccess(
             'ilastik/pxmap_to_obj/load/',
             body={'project_file': str(ilastik_classifiers['pxmap_to_obj']['path'])},
-        )
-        model_id = resp_load.json()['model_id']
-
-        self.assertEqual(resp_load.status_code, 200, resp_load.json())
-        resp_list = self.assertGetSuccess('models')
-        self.assertEqual(resp_list.status_code, 200)
-        rj = resp_list.json()
-        self.assertEqual(rj[model_id]['class'], 'IlastikObjectClassifierFromPixelPredictionsModel')
-        return model_id
+        )['model_id']
+        rl = self.assertGetSuccess('models')
+        self.assertEqual(rl[mid]['class'], 'IlastikObjectClassifierFromPixelPredictionsModel')
+        return mid
 
     def test_load_ilastik_model_with_model_id(self):
-        mid = 'new_model_id'
-        resp_load = self.assertPutSuccess(
+        nmid = 'new_model_id'
+        rmid = self.assertPutSuccess(
             'ilastik/pxmap_to_obj/load/',
+            query={
+                'model_id': nmid,
+            },
             body={
                 'project_file': str(ilastik_classifiers['pxmap_to_obj']['path']),
-                'model_id': mid,
             },
-        )
-        res_mid = resp_load.json()['model_id']
-        self.assertEqual(res_mid, mid)
+        )['model_id']
+        self.assertEqual(rmid, nmid)
 
     def test_load_ilastik_seg_to_obj_model(self):
-        resp_load = self.assertPutSuccess(
+        mid = self.assertPutSuccess(
             'ilastik/seg_to_obj/load/',
             body={'project_file': str(ilastik_classifiers['seg_to_obj']['path'])},
-        )
-        model_id = resp_load.json()['model_id']
-
-        self.assertEqual(resp_load.status_code, 200, resp_load.json())
-        resp_list = self.assertGetSuccess('models')
-        self.assertEqual(resp_list.status_code, 200)
-        rj = resp_list.json()
-        self.assertEqual(rj[model_id]['class'], 'IlastikObjectClassifierFromSegmentationModel')
-        return model_id
+        )['model_id']
+        rl = self.assertGetSuccess('models')
+        self.assertEqual(rl[mid]['class'], 'IlastikObjectClassifierFromSegmentationModel')
+        return mid
 
     def test_ilastik_infer_pixel_probability(self):
         fname = self.copy_input_file_to_server()
-        model_id = self.test_load_ilastik_pixel_model()
-        in_acc_id = self.assertPutSuccess(f'accessors/read_from_file/{fname}').json()
+        mid = self.test_load_ilastik_pixel_model()
+        acc_id = self.assertPutSuccess(f'accessors/read_from_file/{fname}')
 
-        resp_infer = self.assertPutSuccess(
+        self.assertPutSuccess(
             f'pipelines/segment',
-            body={'model_id': model_id, 'accessor_id': in_acc_id, 'channel': 0},
+            body={'model_id': mid, 'accessor_id': acc_id, 'channel': 0},
         )
-        self.assertEqual(resp_infer.status_code, 200, resp_infer.content.decode())
 
 
     def test_ilastik_infer_px_then_ob(self):
@@ -316,9 +301,9 @@ class TestIlastikOverApi(TestServerTestCase):
         px_model_id = self.test_load_ilastik_pixel_model()
         ob_model_id = self.test_load_ilastik_pxmap_to_obj_model()
 
-        in_acc_id = self.assertPutSuccess(f'accessors/read_from_file/{fname}').json()
+        in_acc_id = self.assertPutSuccess(f'accessors/read_from_file/{fname}')
 
-        resp_infer = self.assertPutSuccess(
+        self.assertPutSuccess(
             'ilastik/pipelines/pixel_then_object_classification/infer/',
             body={
                 'px_model_id': px_model_id,
@@ -327,7 +312,6 @@ class TestIlastikOverApi(TestServerTestCase):
                 'channel': 0,
             }
         )
-        self.assertEqual(resp_infer.status_code, 200, resp_infer.content.decode())
 
 
 class TestIlastikOnMultichannelInputs(TestServerTestCase):
@@ -394,38 +378,32 @@ class TestIlastikOnMultichannelInputs(TestServerTestCase):
         """
         copyfile(
             self.pa_input_image,
-            Path(self.assertGetSuccess('paths').json()['inbound_images']) / self.pa_input_image.name
+            Path(self.assertGetSuccess('paths')['inbound_images']) / self.pa_input_image.name
         )
 
-        in_acc_id = self.assertPutSuccess(f'accessors/read_from_file/{self.pa_input_image.name}').json()
+        in_acc_id = self.assertPutSuccess(f'accessors/read_from_file/{self.pa_input_image.name}')
 
-        resp_load_px = self.assertPutSuccess(
+        px_model_id = self.assertPutSuccess(
             'ilastik/seg/load/',
             body={'project_file': str(self.pa_px_classifier)},
-        )
-        self.assertEqual(resp_load_px.status_code, 200, resp_load_px.json())
-        px_model_id = resp_load_px.json()['model_id']
+        )['model_id']
 
-        resp_load_ob = self.assertPutSuccess(
+        ob_model_id  = self.assertPutSuccess(
             'ilastik/pxmap_to_obj/load/',
             body={'project_file': str(self.pa_ob_pxmap_classifier)},
-        )
-        self.assertEqual(resp_load_ob.status_code, 200, resp_load_ob.json())
-        ob_model_id = resp_load_ob.json()['model_id']
+        )['model_id']
 
         # run the pipeline
-        resp_infer = self.assertPutSuccess(
+        obmap_id = self.assertPutSuccess(
             'ilastik/pipelines/pixel_then_object_classification/infer/',
             body={
                 'accessor_id': in_acc_id,
                 'px_model_id': px_model_id,
                 'ob_model_id': ob_model_id,
             }
-        )
-        self.assertEqual(resp_infer.status_code, 200, resp_infer.content.decode())
+        )['output_accessor_id']
 
         # save output object map to file and compare
-        obmap_id = resp_infer.json()['output_accessor_id']
         obmap_acc = self.get_accessor(obmap_id)
         self.assertEqual(obmap_acc.shape_dict['C'], 1)