Merge pull request Quasars#33 from ngergihun/fixes

[FIX] - Backward compatibility and IFG processing

Author: markotoplak

pySNOM/images.py

@@ -297,16 +297,14 @@ def calculate(self, data, mask=None):
         return norm
 
 
-class BackgroundPolyFit(MaskedTransformation):
+class BackgroundPolyFit(Transformation):
     def __init__(self, xorder=1, yorder=1, datatype=DataTypes.Phase):
         self.xorder = int(xorder)
         self.yorder = int(yorder)
         self.datatype = datatype
 
-    def calculate(self, data, mask = None):
-        """ Calculates and returns the fitted polynomial background using mask (if given) without applying it to the data"""
-        if mask is not None:
-            data = mask*data
+    def calculate(self, data):
+        """Calculates and returns the fitted polynomial background using mask (if given) without applying it to the data"""
 
         Z = copy.deepcopy(data)
         x = list(range(0, Z.shape[1]))
@@ -340,6 +338,32 @@ def get_basis(x, y, max_order_x=1, max_order_y=1):
             print("X and Y order must be integer!")
 
         return background
+    
+    def transform(self, data):
+        """Calculates and applies the corrections to the data taking into account the mask if given"""
+        background = self.calculate(data)
+
+        if self.datatype == DataTypes["Amplitude"]:
+            return data / background, background
+        else:
+            return data - background, background
+        
+
+class MaskedBackgroundPolyFit(BackgroundPolyFit,MaskedTransformation):
+    def __init__(self, xorder=1, yorder=1, datatype=DataTypes.Phase):
+        self.xorder = int(xorder)
+        self.yorder = int(yorder)
+        self.datatype = datatype
+
+    def calculate(self, data, mask=None):
+        """Calculates and returns the fitted polynomial background using mask (if given) without applying it to the data"""
+        if mask is not None:
+            data = mask * data
+
+        return BackgroundPolyFit.calculate(self,data)
+    
+    def transform(self, data, mask=None):
+        return MaskedTransformation.transform(self, data, mask=mask)
 
 
 # TODO: Helper functions to create masks or turn other types of masks into 1/Nan mask

pySNOM/interferograms.py

@@ -336,7 +336,10 @@ def transform(self, neaifg):
             pointifg_params["Scan"] = "Fourier Scan"
             pointifg_params["Averaging"] = neaifg.parameters["Averaging"]
 
-            spectra = NeaSpectrum({}, {}, scantype=neaifg.scantype)
+            spectra_params = dict()
+            spectra_params["Scan"] = "Fourier Scan"
+            spectra_params["PixelArea"] = pixel_area
+            spectra = NeaSpectrum({}, spectra_params, scantype=neaifg.scantype)
 
             allchannels = list(neaifg.data.keys())
             optical_channels = [
@@ -385,8 +388,6 @@ def transform(self, neaifg):
                     spectra.data[channelP] = phiFullData
                     spectra.data["Wavenumber"] = fFullData
 
-            spectra._parameters["PixelArea"] = pixel_area
-
         return spectra
 
 

pySNOM/tests/test_transform.py

@@ -2,7 +2,16 @@
 
 import numpy as np
 
-from pySNOM.images import LineLevel, BackgroundPolyFit, SimpleNormalize, DataTypes, AlignImageStack, mask_from_datacondition, dict_from_imagestack
+from pySNOM.images import (
+    LineLevel,
+    BackgroundPolyFit,
+    MaskedBackgroundPolyFit,
+    SimpleNormalize,
+    DataTypes,
+    AlignImageStack,
+    mask_from_datacondition,
+    dict_from_imagestack,
+)
 
 
 class TestLineLevel(unittest.TestCase):
@@ -98,31 +107,47 @@ def test_withmask(self):
         mask = np.ones([10,10])
         mask[4:8,4:8] = np.nan
 
-        t = BackgroundPolyFit(xorder=1,yorder=1,datatype=DataTypes.Phase)
-        out = t.transform(d,mask=mask)
-        np.testing.assert_almost_equal(out[0,0], 0.0)
-        np.testing.assert_almost_equal(out[9,9], 0.0)
+        t = MaskedBackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Phase)
+        out = t.transform(d, mask=mask)
+        np.testing.assert_almost_equal(out[0, 0], 0.0)
+        np.testing.assert_almost_equal(out[9, 9], 0.0)
 
-        t = BackgroundPolyFit(xorder=1,yorder=1,datatype=DataTypes.Amplitude)
-        out = t.transform(d,mask=mask)
-        np.testing.assert_almost_equal(out[0,0], 1.0)
-        np.testing.assert_almost_equal(out[9,9], 1.0)
+        t = MaskedBackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Amplitude)
+        out = t.transform(d, mask=mask)
+        np.testing.assert_almost_equal(out[0, 0], 1.0)
+        np.testing.assert_almost_equal(out[9, 9], 1.0)
 
     def test_withoutmask(self):
         d = np.ones([10,10])
         d[4:8,4:8] = 10
         mask = np.ones([10,10])
         mask[4:8,4:8] = np.nan
 
-        t = BackgroundPolyFit(xorder=1,yorder=1,datatype=DataTypes.Phase)
+        t = MaskedBackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Phase)
         out = t.transform(d)
         np.testing.assert_almost_equal(out[0,0], -0.2975206611570238)
         np.testing.assert_almost_equal(out[9,9], -3.439338842975202)
 
-        t = BackgroundPolyFit(xorder=1,yorder=1,datatype=DataTypes.Amplitude)
+        t = MaskedBackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Amplitude)
         out = t.transform(d)
-        np.testing.assert_almost_equal(out[0,0], 0.7707006369426758)
-        np.testing.assert_almost_equal(out[9,9], 0.22525876833718098)
+        np.testing.assert_almost_equal(out[0, 0], 0.7707006369426758)
+        np.testing.assert_almost_equal(out[9, 9], 0.22525876833718098)
+
+    def test_old_version(self):
+        d = np.ones([10, 10])
+        d[4:8, 4:8] = 10
+        mask = np.ones([10, 10])
+        mask[4:8, 4:8] = np.nan
+
+        t = BackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Phase)
+        out, _ = t.transform(d)
+        np.testing.assert_almost_equal(out[0, 0], -0.2975206611570238)
+        np.testing.assert_almost_equal(out[9, 9], -3.439338842975202)
+
+        t = BackgroundPolyFit(xorder=1, yorder=1, datatype=DataTypes.Amplitude)
+        out, _ = t.transform(d)
+        np.testing.assert_almost_equal(out[0, 0], 0.7707006369426758)
+        np.testing.assert_almost_equal(out[9, 9], 0.22525876833718098)
 
 class TestHelperFunction(unittest.TestCase):