reformat with black

Author: PolarBean

DeepSlice/coord_post_processing/angle_methods.py

@@ -87,7 +87,7 @@ def get_mean_angle(DV_list, ML_list, method, depths=None, species=None):
             weighted_accuracy = [1.0] * len(df_center)
         df_center = np.array(df_center)
         df_center[df_center < min] = min
-        df_center[df_center > max] = max-1
+        df_center[df_center > max] = max - 1
         weighted_accuracy = [weighted_accuracy[int(y)] for y in df_center]
         DV_angle = np.average(DV_list, weights=weighted_accuracy)
         ML_angle = np.average(ML_list, weights=weighted_accuracy)
@@ -110,7 +110,6 @@ def propagate_angles(df, method, species):
         temp = temp[~temp["bad_section"].astype(bool)]
     DV_angle_list, ML_angle_list = calculate_angles(temp)
 
-
     depths = calculate_brain_center_depths(
         temp[["ox", "oy", "oz", "ux", "uy", "uz", "vx", "vy", "vz"]]
     )
@@ -142,4 +141,3 @@ def set_angles(df, DV_angle, ML_angle):
         sections.append(section)
     df[columns] = sections
     return df
-

DeepSlice/coord_post_processing/depth_estimation.py

@@ -6,7 +6,7 @@ def calculate_brain_center_depth(section):
     """
     Calculates the depth of the brain center for a given section
 
-    :param section: the section coordinates as an array consisting of Oxyz,Uxyz,Vxyz 
+    :param section: the section coordinates as an array consisting of Oxyz,Uxyz,Vxyz
     :type section: np.array
     :return: the depth of the brain center
     :rtype: float
@@ -24,7 +24,7 @@ def calculate_brain_center_depth(section):
 def calculate_brain_center_depths(predictions):
     """
     Calculates the depths of the brain center for a series of predictions
-    
+
     :param predictions: dataframe of predictions
     :type predictions: pandas.DataFrame
     :return: a list of depths

DeepSlice/coord_post_processing/plane_alignment_functions/plane_alignment.py

@@ -95,12 +95,11 @@ def rotation_around_axis(axis, angle):
     )
 
 
-
 def make_gaussian_weights(size):
     x = np.linspace(-np.pi, np.pi, size)
-    weights = np.exp(-(x ** 2) / 2) / np.sqrt(2 * np.pi)
-    weights[weights>size-1] = size-1
-    weights[weights<0] = 0
+    weights = np.exp(-(x**2) / 2) / np.sqrt(2 * np.pi)
+    weights[weights > size - 1] = size - 1
+    weights[weights < 0] = 0
     return weights
 
 
@@ -313,4 +312,3 @@ def section_adjust(section, direction, mean):
     dif = angle - mean
     rot = rotate_section(section, -dif, direction)
     return rot
-

DeepSlice/coord_post_processing/spacing_and_indexing.py

@@ -5,8 +5,9 @@
 from .depth_estimation import calculate_brain_center_depths
 from .plane_alignment_functions import plane_alignment
 
+
 def trim_mean(arr: np.array, percent: int) -> float:
-    """"
+    """ "
     Calculates the trimmed mean of an array, sourced from:
     https://gist.github.com/StuffbyYuki/6f25f9f2f302cb5c1e82e4481016ccde
 
@@ -23,8 +24,11 @@ def trim_mean(arr: np.array, percent: int) -> float:
 
 
 def calculate_average_section_thickness(
-    section_numbers: List[Union[int, float]], section_depth: List[Union[int, float]], bad_sections, method="weighted",
-    species="mouse"
+    section_numbers: List[Union[int, float]],
+    section_depth: List[Union[int, float]],
+    bad_sections,
+    method="weighted",
+    species="mouse",
 ) -> float:
     """
     Calculates the average section thickness for a series of predictions
@@ -44,23 +48,21 @@ def calculate_average_section_thickness(
     # inter section depth differences
     depth_spacing = section_depth[:-1] - section_depth[1:]
     # dividing depth spacing by number spacing allows us to control for missing sections
-    weighted_accuracy = calculate_weighted_accuracy(section_numbers, section_depth, species, None, method)
+    weighted_accuracy = calculate_weighted_accuracy(
+        section_numbers, section_depth, species, None, method
+    )
     section_thicknesses = depth_spacing / number_spacing
-    average_thickness = np.average(section_thicknesses, weights = weighted_accuracy[1:])
+    average_thickness = np.average(section_thicknesses, weights=weighted_accuracy[1:])
     return average_thickness
 
 
-
-
-
-
 def ideal_spacing(
     section_numbers: List[Union[int, float]],
     section_depth: List[Union[int, float]],
     average_thickness: Union[int, float],
     bad_sections: List[bool] = None,
-    method = "weighted",
-    species = "mouse"
+    method="weighted",
+    species="mouse",
 ) -> float:
     """
     Calculates the ideal spacing for a series of predictions
@@ -77,9 +79,13 @@ def ideal_spacing(
     # unaligned voxel position of section numbers (evenly spaced depths)
     index_spaced_depth = section_numbers * average_thickness
     # average distance between the depths and the evenly spaced depths
-    
-    weighted_accuracy = calculate_weighted_accuracy(section_numbers, section_depth, species, bad_sections, method)
-    distance_to_ideal = np.average(section_depth - index_spaced_depth, weights = weighted_accuracy)
+
+    weighted_accuracy = calculate_weighted_accuracy(
+        section_numbers, section_depth, species, bad_sections, method
+    )
+    distance_to_ideal = np.average(
+        section_depth - index_spaced_depth, weights=weighted_accuracy
+    )
     # adjust the evenly spaced depths to minimise their distance to the predicted depths
     ideal_index_spaced_depth = index_spaced_depth + distance_to_ideal
     return ideal_index_spaced_depth
@@ -111,7 +117,9 @@ def enforce_section_ordering(predictions):
     :return: the input dataframe ordered by section number
     :rtype: pandas.DataFrame
     """
-    predictions = predictions.sort_values(by=["nr"], ascending=True).reset_index(drop=True)
+    predictions = predictions.sort_values(by=["nr"], ascending=True).reset_index(
+        drop=True
+    )
     if len(predictions) == 1:
         raise ValueError("Only one section found, cannot space according to index")
     if "nr" not in predictions:
@@ -124,7 +132,7 @@ def enforce_section_ordering(predictions):
         depths = np.array(depths)
         direction = determine_direction_of_indexing(depths)
         predictions["depths"] = depths
-        
+
         temp = predictions.copy()
         if direction == "caudal-rostro":
             ascending = False
@@ -133,21 +141,30 @@ def enforce_section_ordering(predictions):
         if "bad_section" in temp:
             temp_good = temp[temp["bad_section"] == False].copy().reset_index(drop=True)
             temp_good_copy = temp_good.copy()
-            temp_good_copy = temp_good_copy.sort_values(by=["depths"], ascending=ascending).reset_index(
-                drop=True
-            )
+            temp_good_copy = temp_good_copy.sort_values(
+                by=["depths"], ascending=ascending
+            ).reset_index(drop=True)
             temp_good["oy"] = temp_good_copy["oy"]
-            
-            predictions.loc[predictions["bad_section"] == False, "oy"] = temp_good["oy"].values
+
+            predictions.loc[predictions["bad_section"] == False, "oy"] = temp_good[
+                "oy"
+            ].values
         else:
-            temp = temp.sort_values(by=["depths"], ascending=ascending).reset_index(drop=True)
+            temp = temp.sort_values(by=["depths"], ascending=ascending).reset_index(
+                drop=True
+            )
 
-        
             predictions["oy"] = temp["oy"].values
     return predictions
 
 
-def space_according_to_index(predictions, section_thickness = None, voxel_size = None, suppress = False, species = "mouse"):
+def space_according_to_index(
+    predictions,
+    section_thickness=None,
+    voxel_size=None,
+    suppress=False,
+    species="mouse",
+):
     """
     Space evenly according to the section indexes, if these indexes do not represent the precise order in which the sections were
     cut, this will lead to less accurate predictions. Section indexes must account for missing sections (ie, if section 3 is missing
@@ -161,7 +178,7 @@ def space_according_to_index(predictions, section_thickness = None, voxel_size =
     if voxel_size == None:
         raise ValueError("voxel_size must be specified")
     if section_thickness is not None:
-        section_thickness/=voxel_size
+        section_thickness /= voxel_size
     predictions["oy"] = predictions["oy"].astype(float)
     if len(predictions) == 1:
         raise ValueError("Only one section found, cannot space according to index")
@@ -170,24 +187,29 @@ def space_according_to_index(predictions, section_thickness = None, voxel_size =
             "No section indexes found, cannot space according to a missing index. You likely did not run predict() with section_numbers=True"
         )
     else:
-        if 'bad_section' in predictions:
-            bad_sections = predictions['bad_section'].values
+        if "bad_section" in predictions:
+            bad_sections = predictions["bad_section"].values
         else:
             bad_sections = None
         predictions = enforce_section_ordering(predictions)
         depths = calculate_brain_center_depths(predictions)
         depths = np.array(depths)
         if not section_thickness:
             section_thickness = calculate_average_section_thickness(
-                predictions["nr"], section_depth = depths, bad_sections=bad_sections, species=species
+                predictions["nr"],
+                section_depth=depths,
+                bad_sections=bad_sections,
+                species=species,
             )
             if not suppress:
-                print(f'predicted thickness is {section_thickness * voxel_size}µm')
+                print(f"predicted thickness is {section_thickness * voxel_size}µm")
         else:
             if not suppress:
-                print(f'specified thickness is {section_thickness * voxel_size}µm')
+                print(f"specified thickness is {section_thickness * voxel_size}µm")
 
-        calculated_spacing = ideal_spacing(predictions["nr"], depths, section_thickness, bad_sections, species=species)
+        calculated_spacing = ideal_spacing(
+            predictions["nr"], depths, section_thickness, bad_sections, species=species
+        )
         distance_to_ideal = calculated_spacing - depths
         predictions["oy"] = predictions["oy"] + distance_to_ideal
     return predictions
@@ -223,10 +245,12 @@ def number_sections(filenames: List[str], legacy=False) -> List[int]:
     return section_numbers
 
 
-def set_bad_sections_util(df: pd.DataFrame, bad_sections: List[str], auto = False) -> pd.DataFrame:
+def set_bad_sections_util(
+    df: pd.DataFrame, bad_sections: List[str], auto=False
+) -> pd.DataFrame:
     """
     Sets the damaged sections and sections which deepslice may not perform well on for a series of predictions
-    
+
     :param bad_sections: List of bad sections
     :param df: dataframe of predictions
     :param auto: automatically set bad sections based on if theyre badly positioned relative to their section index
@@ -240,23 +264,25 @@ def set_bad_sections_util(df: pd.DataFrame, bad_sections: List[str], auto = Fals
     bad_section_indexes = [
         df.Filenames.str.contains(bad_section) for bad_section in bad_sections
     ]
-    if np.any([np.sum(x)>1 for x in bad_section_indexes]):
-        raise ValueError("Multiple sections match the same bad section string, make sure each bad section string is unique")
+    if np.any([np.sum(x) > 1 for x in bad_section_indexes]):
+        raise ValueError(
+            "Multiple sections match the same bad section string, make sure each bad section string is unique"
+        )
     bad_section_indexes = [np.where(x)[0] for x in bad_section_indexes]
     bad_section_indexes = np.concatenate(bad_section_indexes)
     df.loc[~df.index.isin(bad_section_indexes), "bad_section"] = False
     if auto:
-        df['depths'] = calculate_brain_center_depths(df)
-        x = df['nr'].values
-        y = df['depths'].values
-        m,b = np.polyfit(x,y,1)
-        residuals = y - (m*x + b)
-        outliers = np.abs(residuals) > 1.5*np.std(residuals)
-        df.loc[outliers, 'bad_section'] = True
-        
+        df["depths"] = calculate_brain_center_depths(df)
+        x = df["nr"].values
+        y = df["depths"].values
+        m, b = np.polyfit(x, y, 1)
+        residuals = y - (m * x + b)
+        outliers = np.abs(residuals) > 1.5 * np.std(residuals)
+        df.loc[outliers, "bad_section"] = True
+
     df.loc[bad_section_indexes, "bad_section"] = True
     # make the other sections are False
-    
+
     bad_sections_found = np.sum(bad_section_indexes)
     # Tell the user which sections were identified as bad
     if bad_sections_found > 0:
@@ -267,10 +293,16 @@ def set_bad_sections_util(df: pd.DataFrame, bad_sections: List[str], auto = Fals
     return df
 
 
-def calculate_weighted_accuracy(section_numbers: List[int], depths: List[float], species: str, bad_sections: List[Optional[bool]]  = None, method: str = "weighted") -> List[float]:
+def calculate_weighted_accuracy(
+    section_numbers: List[int],
+    depths: List[float],
+    species: str,
+    bad_sections: List[Optional[bool]] = None,
+    method: str = "weighted",
+) -> List[float]:
     """
     Calculates the weighted accuracy of a list of section numbers for a given species
-    
+
     :param section_numbers: List of section numbers
     :param species: Species to calculate accuracy for
     :param bad_sections: List of bad sections
@@ -296,8 +328,10 @@ def calculate_weighted_accuracy(section_numbers: List[int], depths: List[float],
         weighted_accuracy = [1 for y in section_numbers]
     if len(section_numbers) <= 2:
         weighted_accuracy = [0.5, 0.5]
-        
+
     if bad_sections is not None:
-        weighted_accuracy = [x if y == False else 0 for x,y in zip(weighted_accuracy,bad_sections)]
-        
-    return weighted_accuracy
+        weighted_accuracy = [
+            x if y == False else 0 for x, y in zip(weighted_accuracy, bad_sections)
+        ]
+
+    return weighted_accuracy