emdbva 0.0.1.dev146__tar.gz → 0.0.1.dev147__tar.gz

{emdbva-0.0.1.dev146/emdbva.egg-info → emdbva-0.0.1.dev147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev146
+Version: 0.0.1.dev147
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev146 → emdbva-0.0.1.dev147/emdbva.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev146
+Version: 0.0.1.dev147
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev146 → emdbva-0.0.1.dev147}/va/utils/stars.py

@@ -479,87 +479,174 @@ class GetStars:
         plt.plot(levels, corrected_curve, color='red', label='FSC corrected')
         plt.plot(levels, phase_rand_curve, color='blue', label='Phase randomized')
 
-        feature_area = 0.0
-
-        if valid_intersections:
-            intersection_xs = [x for x, y in valid_intersections]
-
-            # Use searchsorted instead of exact equality.
-            boundaries = [np.searchsorted(levels, x) for x in intersection_xs]
-            boundaries = [max(0, min(idx, len(levels))) for idx in boundaries]
-            boundaries = sorted(set(boundaries))
-
-            for i in range(len(boundaries)):
-                idx_start = boundaries[i]
-
-                if i == len(boundaries) - 1:
-                    idx_end = len(levels)
-                else:
-                    idx_end = boundaries[i + 1]
-
-                if idx_end <= idx_start:
-                    continue
-
-                seg_levels = levels[idx_start:idx_end]
-                seg_corrected = corrected_curve[idx_start:idx_end]
-                seg_phase = phase_rand_curve[idx_start:idx_end]
-
-                if len(seg_levels) < 2:
-                    continue
-
-                finite_segment = (
-                        np.all(np.isfinite(seg_levels))
-                        and np.all(np.isfinite(seg_corrected))
-                        and np.all(np.isfinite(seg_phase))
-                )
-
-                if not finite_segment:
-                    continue
-
-                above = seg_corrected >= seg_phase
-
-                plt.fill_between(
-                    seg_levels,
-                    seg_corrected,
-                    seg_phase,
-                    where=above,
-                    color='pink',
-                    alpha=0.5,
-                )
+        frequency = 1 / self.randomise_from()
 
-                if np.all(above):
-                    cur_area = np.trapz(
-                        seg_corrected - seg_phase,
-                        seg_levels,
-                    )
-                    feature_area += cur_area
+        # ============================================================
+        # FEATURE ZONE (PINK)
+        # ============================================================
+        # Feature area is independent of the randomization frequency.
+        #
+        # Count ALL area between the two curves wherever:
+        #
+        #     corrected FSC > phase-randomized FSC
+        #
+        # over the entire available frequency range.
+
+        feature_delta = corrected_curve - phase_rand_curve
+
+        feature_area = np.trapz(
+            np.clip(feature_delta, 0, None),
+            levels
+        )
 
-        frequency = 1 / self.randomise_from()
+        plt.fill_between(
+            levels,
+            corrected_curve,
+            phase_rand_curve,
+            where=(corrected_curve >= phase_rand_curve),
+            interpolate=True,
+            color='pink',
+            alpha=0.5,
+        )
 
-        closest_idx = int(np.argmin(np.abs(levels - frequency)))
+        # ============================================================
+        # OVERFIT ZONE (BLUE)
+        # ============================================================
+        # Blue area DOES depend on randomization frequency.
+        # It starts exactly at:
+        #
+        #     frequency = 1 / self.randomise_from()
+        #
+        # and is the positive area between phase-randomized FSC
+        # and the x-axis.
+
+        overfit_area = 0.0
+
+        if levels[0] <= frequency < levels[-1]:
+            # Find the first original data point AFTER the exact
+            # randomization frequency.
+            start_idx = np.searchsorted(
+                levels,
+                frequency,
+                side='right'
+            )
 
-        overfit_x = levels[closest_idx:]
-        overfit_y = phase_rand_curve[closest_idx:]
+            # Interpolate the phase-randomized FSC at the exact
+            # randomization frequency.
+            phase_at_frequency = np.interp(
+                frequency,
+                levels,
+                phase_rand_curve
+            )
 
-        valid_overfit = np.isfinite(overfit_x) & np.isfinite(overfit_y)
+            # Explicitly insert the exact randomization frequency
+            # as the first point.
+            overfit_x = np.concatenate(
+                ([frequency], levels[start_idx:])
+            )
 
-        overfit_x = overfit_x[valid_overfit]
-        overfit_y = overfit_y[valid_overfit]
+            overfit_phase = np.concatenate(
+                ([phase_at_frequency], phase_rand_curve[start_idx:])
+            )
 
-        if len(overfit_x) >= 2:
-            y_values = np.zeros(len(overfit_x))
-            overfit_area = np.trapz(overfit_y, overfit_x)
+            # Count only positive phase-randomized FSC as blue area.
+            overfit_area = np.trapz(
+                np.clip(overfit_phase, 0, None),
+                overfit_x
+            )
 
+            # Draw blue area starting exactly at randomization frequency.
             plt.fill_between(
                 overfit_x,
-                overfit_y,
-                y_values,
-                where=(overfit_y >= 0),
+                overfit_phase,
+                0,
+                where=(overfit_phase >= 0),
+                interpolate=True,
                 color='blue',
                 alpha=0.5,
             )
-        else:
-            overfit_area = 0.0
+
+        # feature_area = 0.0
+        #
+        # if valid_intersections:
+        #     intersection_xs = [x for x, y in valid_intersections]
+        #
+        #     # Use searchsorted instead of exact equality.
+        #     boundaries = [np.searchsorted(levels, x) for x in intersection_xs]
+        #     boundaries = [max(0, min(idx, len(levels))) for idx in boundaries]
+        #     boundaries = sorted(set(boundaries))
+        #
+        #     for i in range(len(boundaries)):
+        #         idx_start = boundaries[i]
+        #
+        #         if i == len(boundaries) - 1:
+        #             idx_end = len(levels)
+        #         else:
+        #             idx_end = boundaries[i + 1]
+        #
+        #         if idx_end <= idx_start:
+        #             continue
+        #
+        #         seg_levels = levels[idx_start:idx_end]
+        #         seg_corrected = corrected_curve[idx_start:idx_end]
+        #         seg_phase = phase_rand_curve[idx_start:idx_end]
+        #
+        #         if len(seg_levels) < 2:
+        #             continue
+        #
+        #         finite_segment = (
+        #                 np.all(np.isfinite(seg_levels))
+        #                 and np.all(np.isfinite(seg_corrected))
+        #                 and np.all(np.isfinite(seg_phase))
+        #         )
+        #
+        #         if not finite_segment:
+        #             continue
+        #
+        #         above = seg_corrected >= seg_phase
+        #
+        #         plt.fill_between(
+        #             seg_levels,
+        #             seg_corrected,
+        #             seg_phase,
+        #             where=above,
+        #             color='pink',
+        #             alpha=0.5,
+        #         )
+        #
+        #         if np.all(above):
+        #             cur_area = np.trapz(
+        #                 seg_corrected - seg_phase,
+        #                 seg_levels,
+        #             )
+        #             feature_area += cur_area
+        #
+        # frequency = 1 / self.randomise_from()
+        #
+        # closest_idx = int(np.argmin(np.abs(levels - frequency)))
+        #
+        # overfit_x = levels[closest_idx:]
+        # overfit_y = phase_rand_curve[closest_idx:]
+        #
+        # valid_overfit = np.isfinite(overfit_x) & np.isfinite(overfit_y)
+        #
+        # overfit_x = overfit_x[valid_overfit]
+        # overfit_y = overfit_y[valid_overfit]
+        #
+        # if len(overfit_x) >= 2:
+        #     y_values = np.zeros(len(overfit_x))
+        #     overfit_area = np.trapz(overfit_y, overfit_x)
+        #
+        #     plt.fill_between(
+        #         overfit_x,
+        #         overfit_y,
+        #         y_values,
+        #         where=(overfit_y >= 0),
+        #         color='blue',
+        #         alpha=0.5,
+        #     )
+        # else:
+        #     overfit_area = 0.0
 
         plt.legend(loc='best', fontsize='x-small')
 

{emdbva-0.0.1.dev146 → emdbva-0.0.1.dev147}/va/version.py

@@ -18,5 +18,5 @@ under the License.
 
 """
 
-__version__ = '0.0.1.dev146'
+__version__ = '0.0.1.dev147'
 __em_statistics_version__ = '202505.v01'