Unit tests for out argument to processors

Wrappers/Python/cil/framework/framework.py

@@ -3898,12 +3898,12 @@ def get_output(self, out=None):
         Parameters
         ----------
         out : DataContainer, optional
-           Fills the referenced DataContainer with the processed data and suppresses the return
+           Fills the referenced DataContainer with the processed data
 
         Returns
         -------
         DataContainer
-            The processed data. Suppressed if `out` is passed
+            The processed data
         """
         if self.output is None or self.shouldRun:
             if out is None:

Wrappers/Python/cil/processors/Masker.py

@@ -177,6 +177,7 @@ def process(self, out=None):
             arr = out.as_array()
             return_arr = True
         else:
+            out.fill(data.as_array())
             arr = out.as_array()
 
         #assumes mask has 'as_array' method, i.e. is a DataContainer or is a numpy array

Wrappers/Python/cil/processors/Normaliser.py

@@ -116,7 +116,12 @@ def process(self, out=None):
         elif projections.number_of_dimensions == 2:
             a = Normaliser.Normalise_projection(projections.as_array(),
                                                 flat, dark, self.tolerance)
-        y = type(projections)( a , True,
-                    dimension_labels=projections.dimension_labels,
-                    geometry=projections.geometry)
-        return y
+
+        if out is None:
+            out = type(projections)( a , True,
+                        dimension_labels=projections.dimension_labels,
+                        geometry=projections.geometry)
+        else:
+            out.fill(a)
+
+        return out

Wrappers/Python/cil/processors/RingRemover.py

@@ -85,7 +85,8 @@ def process(self, out = None):
         vertical = geom.pixel_num_v
 
         # allocate datacontainer space
-        out = 0.*data
+        if out is None:
+            out = 0.*data
 
         # for non multichannel data
         if 'channel' not in geom.dimension_labels:

Wrappers/Python/test/test_out_in_place.py

@@ -22,7 +22,7 @@
 import numpy as np
 
 from cil.utilities.errors import InPlaceError
-from cil.framework import AcquisitionGeometry, ImageGeometry, VectorGeometry
+from cil.framework import AcquisitionGeometry, ImageGeometry, VectorGeometry, DataContainer
 
 from cil.optimisation.operators import IdentityOperator, WaveletOperator
 from cil.optimisation.functions import  KullbackLeibler, ConstantFunction, TranslateFunction, soft_shrinkage, L1Sparsity, BlockFunction
@@ -38,6 +38,8 @@
      IndicatorBox, TotalVariation,  SumFunction, SumScalarFunction, \
     WeightedL2NormSquared, MixedL11Norm, ZeroFunction
 
+from cil.processors import AbsorptionTransmissionConverter, Binner, CentreOfRotationCorrector, MaskGenerator, Masker, Normaliser, Padder, \
+RingRemover, Slicer, TransmissionAbsorptionConverter
 
 import numpy
 
@@ -313,3 +315,155 @@ def test_proximal_out(self):
                 result=self.get_result(operator, 'adjoint', data)
                 self.out_test(result, operator, 'adjoint',  data)
                 self.in_place_test(result,operator,  'adjoint',  data)
+
+class TestProcessorOutandInPlace(CCPiTestClass):
+    def setUp(self):
+
+        self.data_arrays=[np.random.normal(0,1, (10,20)).astype(np.float32),  
+                          np.array(range(0,65500, 328), dtype=np.uint16).reshape((10,20)),
+                          np.random.uniform(0,1,(10,20)).astype(np.float32)]
+
+        ag_parallel_2D = AcquisitionGeometry.create_Parallel2D()
+        angles = np.linspace(0, 360, 10, dtype=np.float32)
+        ag_parallel_2D.set_angles(angles)
+        ag_parallel_2D.set_panel(20)
+
+        ag_parallel_3D = AcquisitionGeometry.create_Parallel3D()
+        ag_parallel_3D.set_angles(angles)
+        ag_parallel_3D.set_panel([20,2])
+
+        ag_cone_2D = AcquisitionGeometry.create_Cone2D(source_position=[0,-10],detector_position=[0,10])
+        ag_cone_2D.set_angles(angles)
+        ag_cone_2D.set_panel(20)
+
+        ag_cone_3D = AcquisitionGeometry.create_Cone3D(source_position=[0,-10,0],detector_position=[0,10,0])
+        ag_cone_3D.set_angles(angles)
+        ag_cone_3D.set_panel([20,2])
+
+        self.geometry_test_list = [ag_parallel_2D, ag_parallel_3D, ag_cone_2D, ag_cone_3D]
+        self.data_test_list= [geom.allocate(None) for geom in self.geometry_test_list]
+
+        flat_field = self.data_test_list[0]*1
+        dark_field = self.data_test_list[0]*1e-5
+
+        self.processor_list = [
+            TransmissionAbsorptionConverter(min_intensity=0.01),
+            AbsorptionTransmissionConverter(),
+            RingRemover(),
+            Slicer(roi={'horizontal':(None,None,2),'angle':(None,None,2)}), 
+            Binner(roi={'horizontal':(None,None,2),'angle':(None,None,2)}), 
+            Padder(pad_width=1)]
+        self.processor_out_same_size = [
+            True,
+            True,
+            True,
+            False,
+            False,
+            False
+        ]
+
+    def get_result(self, processor, data, *args):
+        input=data.copy() #To check that it isn't changed after function calls
+        try:
+            processor.set_input(data)
+            out = processor.get_output()
+            self.assertDataArraysInContainerAllClose(input, data, rtol=1e-5, msg= "In case processor.set_input(data), processor.get_output() where processor is  " + processor.__class__.__name__+ " the input data has been incorrectly affected by the calculation.")
+            return out
+        except NotImplementedError:
+            print("get_result test not implemented for  " + processor.__class__.__name__)
+            return None
+
+    def in_place_test(self, desired_result, processor, data, output_same_size=True):
+            if output_same_size==True:
+                out = data.copy()
+            else:
+                out=desired_result.copy()
+            try:
+                processor.set_input(data)
+                processor.get_output(out=out)
+                self.assertDataArraysInContainerAllClose(desired_result, out, rtol=1e-5, msg= "In place calculation failed for processor.set_input(data), processor.get_output(out=data) where processor is  " + processor.__class__.__name__+ "." )
+
+            except (InPlaceError, NotImplementedError):
+                print("in_place_test test not implemented for  " + processor.__class__.__name__)
+                pass
+
+    def out_test(self, desired_result, processor, data, output_same_size=True):
+        input = data.copy()
+        if output_same_size==True:
+            out=0*(data.copy())
+        else:
+            out=0*(desired_result.copy())
+
+        try:
+            processor.set_input(input)
+            output = processor.get_output(out=out)
+
+            self.assertDataArraysInContainerAllClose(desired_result, out, rtol=1e-5, msg= "Calculation failed using processor.set_input(data), processor.get_output(out=out) where func is  " + processor.__class__.__name__+ ".")
+            self.assertDataArraysInContainerAllClose(input, data,  rtol=1e-5, msg= "In case processor.set_input(data), processor.get_output(out=data) where processor is  " + processor.__class__.__name__+ " the input data has been incorrectly affected by the calculation. ")
+            self.assertDataArraysInContainerAllClose(desired_result, output,  rtol=1e-5, msg= "In case processor.set_input(data), output=processor.get_output(out=data) where processor is  " + processor.__class__.__name__+ " the processor supresses the output. ")
+
+        except (InPlaceError, NotImplementedError):
+            print("out_test test not implemented for  " + processor.__class__.__name__)
+            pass
+
+    def test_out(self):
+
+        for geom in self.geometry_test_list:
+            for data_array in self.data_arrays:
+                data=geom.allocate(None)
+                try:
+                    data.fill(data_array)
+                except:
+                    data.fill(np.repeat(data_array[:,None, :], repeats=2, axis=1))
+
+                i = 0
+                for processor in self.processor_list:
+                    result=self.get_result(processor, data)
+                    self.out_test(result, processor, data, output_same_size=self.processor_out_same_size[i])
+                    self.in_place_test(result, processor, data, output_same_size=self.processor_out_same_size[i])
+                    i+=1
+
+                # Test the processors that need data size as an input
+                processor = Normaliser(flat_field=data.get_slice(angle=0).as_array()*1, dark_field=data.get_slice(angle=0).as_array()*1e-5)
+                result=self.get_result(processor, data)
+                self.out_test(result, processor, data)
+                self.in_place_test(result, processor, data)
+
+                processor = MaskGenerator.median(threshold_factor=3, window=7)
+                mask=self.get_result(processor, data)
+                self.out_test(mask, processor, data)
+                self.in_place_test(mask, processor, data)
+
+                processor = Masker.median(mask=mask)
+                result=self.get_result(processor, data)
+                self.out_test(result, processor, data)
+                self.in_place_test(result, processor, data)
+
+    def test_centre_of_rotation_out(self):
+        for geom in self.geometry_test_list[0:2]:
+            for data_array in self.data_arrays:
+                data=geom.allocate(None)
+                try:
+                    data.fill(data_array)
+                except:
+                    data.fill(np.repeat(data_array[:,None, :], repeats=2, axis=1))
+                processor = CentreOfRotationCorrector.xcorrelation(ang_tol=180)
+                result=self.get_result(processor, data)
+                # out_test fails because the processor only updates geometry, I think this is expected behaviour
+                # self.out_test(result, processor, data)
+                # test geometry instead
+                input = data.copy()
+                out=0*(data.copy())
+                try:
+                    processor.set_input(input)
+                    output = processor.get_output(out=out)
+
+                    numpy.testing.assert_array_equal(result.geometry.config.system.rotation_axis.position, out.geometry.config.system.rotation_axis.position, err_msg= "Calculation failed using processor.set_input(data), processor.get_output(out=out) where func is  " + processor.__class__.__name__+ ".")
+                    numpy.testing.assert_array_equal(input.geometry.config.system.rotation_axis.position, data.geometry.config.system.rotation_axis.position,  err_msg= "In case processor.set_input(data), processor.get_output(out=data) where processor is  " + processor.__class__.__name__+ " the input data has been incorrectly affected by the calculation. ")
+                    self.assertDataArraysInContainerAllClose(out, output,  rtol=1e-5, msg= "In case processor.set_input(data), output=processor.get_output(out=data) where processor is  " + processor.__class__.__name__+ " the processor incorrectly supresses the output. ")
+
+                except (InPlaceError, NotImplementedError):
+                    print("out_test_for_geometry test not implemented for  " + processor.__class__.__name__)
+                    pass
+
+                self.in_place_test(result, processor, data)