Shannon Entropy: Convert to log2 and test (#184)

* Convert to log2 and test

* Update intensity metric

* Stable

Author: zacsimile

src/aslm/model/aslm_analysis.py

@@ -72,19 +72,26 @@ def image_intensity(self, input_array, psf_support_diameter_xy):
         image_dimensions = input_array.ndim
 
         if image_dimensions == 2:
+            axes = (0, 1)
             (image_height, image_width) = input_array.shape
             number_of_images = 1
         elif image_dimensions == 3:
+            axes = (1, 2)
             (number_of_images, image_height, image_width) = input_array.shape
         else:
             raise ValueError("Only 2D and 3D Images Supported.")
 
         #  Preallocate Array
         entropy = np.zeros(number_of_images)
 
-        for image_idx in range(int(number_of_images)):
-            # Add entropy value to the entropy array
-            entropy[image_idx] = np.sum(input_array[image_idx,...])
+        s = np.prod([input_array.shape[x]**2 / psf_support_diameter_xy for x in axes])
+
+        if number_of_images == 1:
+            entropy[0] = np.sum(input_array)/s
+        else:
+            for image_idx in range(int(number_of_images)):
+                # Add entropy value to the entropy array
+                entropy[image_idx] = np.sum(input_array[image_idx,...])/s
 
         return entropy
 
@@ -150,21 +157,16 @@ def normalized_dct_shannon_entropy(self,
         return entropy
 
     def fast_normalized_dct_shannon_entropy(self,
-                                       input_array,
-                                       psf_support_diameter_xy):
-
-        axes = (0, 1)
-        sl = slice(None)
-        if input_array.ndim > 2:
-            axes = (1, 2)
-            sl = (slice(None), np.newaxis, np.newaxis)
+                                            input_array,
+                                            psf_support_diameter_xy):
 
-        dct_array = dctn(input_array, type=2, axes=axes)
-        abs_array = np.abs(dct_array / np.atleast_1d(np.linalg.norm(dct_array, axis=axes))[sl])
-        image_entropy = -2 * np.nansum(abs_array * np.log(abs_array), axis=axes) \
-                        / np.prod([input_array.shape[x] / psf_support_diameter_xy for x in axes])
+        dct_array = dctn(input_array, type=2)
+        abs_array = np.abs(dct_array / np.linalg.norm(dct_array))
+        yh = int(input_array.shape[1]//psf_support_diameter_xy)
+        xh = int(input_array.shape[0]//psf_support_diameter_xy)
+        entropy = -2*np.nansum(abs_array[:xh,:yh]*np.log2(abs_array[:xh,:yh]))/(yh*xh)
 
-        return np.atleast_1d(image_entropy)
+        return np.atleast_1d(entropy)
 
     def estimate_image_resolution(self,
                                   input_array,

src/aslm/model/devices/daq/daq_base.py

@@ -282,6 +282,10 @@ def update_etl_parameters(self, microscope_state, channel, galvo_parameters, rea
             Duration of time necessary to readout a camera frame.
         """
         laser, resolution_mode, zoom = channel['laser'], microscope_state['resolution_mode'],  microscope_state['zoom']
+        if resolution_mode == 'high':
+            # TODO: Temporary hard code because I don't want to chase down why the dictionaries are getting
+            #       passed out of order again.
+            zoom = 'N/A'
         remote_focus_dict = self.etl_constants.ETLConstants[resolution_mode][zoom][laser]
 
         # Use defaults of 0 in the case they are not provided

src/aslm/model/model_features/autofocus.py

@@ -118,8 +118,8 @@ def get_steps(self, ranges, step_size):
     def pre_func_signal(self):
         settings = self.model.experiment.AutoFocusParameters
         # self.focus_pos = args[2]  # Current position
-        # self.focus_pos = self.model.focus_pos # TODO: get focus position from model right now.
-        self.focus_pos = self.model.get_stage_position()['f_pos']
+        self.focus_pos = self.model.focus_pos # TODO: get focus position from model right now.
+        # self.focus_pos = self.model.get_stage_position()['f_pos']
         self.total_frame_num = self.get_autofocus_frame_num() #total frame num
         self.coarse_steps, self.init_pos = 0, 0
         if settings['fine_selected']:
@@ -184,7 +184,7 @@ def in_func_data(self, frame_ids=[]):
 
             # print('entropy:', self.f_frame_id, self.frame_num, self.f_pos, entropy)
 
-            self.model.logger.debug(f'Appending plot data focus, entropy: {self.f_pos}, {entropy}')
+            self.model.logger.debug(f'Appending plot data for frame {self.f_frame_id} focus: {self.f_pos}, entropy: {entropy[0]}')
             self.plot_data.append([self.f_pos, entropy[0]])
             # Need to initialize entropy above for the first iteration of the autofocus routine.
             # Need to initialize entropy_vector above for the first iteration of the autofocus routine.

test/model/test_aslm_analysis.py

@@ -41,12 +41,52 @@
 # Local Imports
 # sys.path.append('../../../')
 
+def box(size):
+    x = np.linspace(0,1,100)
+    X, Y = np.meshgrid(x,x)
+    l = (1-size)/2
+    u = l +  size
+    image = (X > l) & (X < u) & (Y > l) & (Y < u)
+    return image.astype(float)
+
+def power_tent(r, off, scale, sigma, alpha):
+    return off + scale*(1-np.abs(sigma*r)**alpha)
+
+def power_tent_res(x, r, val):
+    return power_tent(r, *x)-val
+
+def rsq(res_func, x, r, val):
+    ss_err = (res_func(x,r,val)**2).sum()
+    ss_tot = ((val-val.mean())**2).sum()
+    rsq = 1 - (ss_err/ss_tot)
+    return rsq
+
+def test_fast_normalized_dct_shannon_entropy_tent():
+    from scipy.ndimage import gaussian_filter
+    from scipy.optimize import least_squares
+
+    from aslm.model.aslm_analysis import Analysis
+
+    anal = Analysis()
+
+    im = box(0.5)
+
+    r = range(0,60)
+    points = np.zeros((len(r),))
+    for i in r:
+        points[i] = anal.fast_normalized_dct_shannon_entropy(gaussian_filter(im,i),1)[0]
+        
+    res = least_squares(power_tent_res, [np.min(points),np.max(points),1,0.5], args=(r,points))
+
+    assert(rsq(power_tent_res, res.x, r, points) > 0.9)
+
 def test_fast_normalized_dct_shannon_entropy():
     from aslm.model.aslm_analysis import Analysis
 
     anal = Analysis()
 
-    image_array = np.ones((np.random.randint(1,4),128,128)).squeeze()
+    # image_array = np.ones((np.random.randint(1,4),128,128)).squeeze()
+    image_array = np.ones((128, 128)).squeeze()
     psf_support_diameter_xy = np.random.randint(3, 10)
 
     entropy = anal.fast_normalized_dct_shannon_entropy(image_array, psf_support_diameter_xy)