emdbva 0.0.1.dev135__tar.gz → 0.0.1.dev137__tar.gz

{emdbva-0.0.1.dev135/emdbva.egg-info → emdbva-0.0.1.dev137}/PKG-INFO

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

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137/emdbva.egg-info}/PKG-INFO

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

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137}/emdbva.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ va/metrics/contour_level_predicator.py
 va/metrics/emda_mmcc.py
 va/metrics/emringer.py
 va/metrics/inclusion.py
+va/metrics/map_data_validation.py
 va/metrics/overlap_percentage.py
 va/metrics/phaserandomization.py
 va/metrics/phenix_cc.py

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137}/va/mainva.py

@@ -58,6 +58,7 @@ def allruns(validationobj, runs):
 
     # Projections
     if 'projection' in runs:
+        validationobj.map_data_validation()
         validationobj.new_projection()
         validationobj.relion_mask_evaluation()
 

emdbva-0.0.1.dev137/va/metrics/map_data_validation.py

@@ -0,0 +1,59 @@
+import io
+import os
+from collections import OrderedDict
+from pathlib import Path
+import mrcfile
+
+
+def _normalise_map_input(map_input):
+    if hasattr(map_input, "fullname"):
+        return map_input.fullname
+    if hasattr(map_input, "filename"):
+        return map_input.filename
+    return str(map_input)
+
+
+def validate_single_map(map_input):
+    map_path = Path(_normalise_map_input(map_input))
+    messages = io.StringIO()
+
+    result = OrderedDict([
+        ("file", str(map_path)),
+        ("exists", map_path.exists()),
+        ("valid", False),
+        ("messages", ""),
+        ("error", None),
+    ])
+
+    if not map_path.exists():
+        result["error"] = "File does not exist"
+        return result
+
+    try:
+        valid = mrcfile.validate(str(map_path), print_file=messages)
+        result["valid"] = bool(valid)
+        result["messages"] = messages.getvalue().strip()
+    except Exception as exc:
+        result["error"] = str(exc)
+        result["messages"] = messages.getvalue().strip()
+
+    return result
+
+
+def run_map_data_validation(map_inputs):
+    map_results = OrderedDict()
+
+    for map_input in map_inputs:
+        if map_input is None:
+            continue
+
+        map_path = _normalise_map_input(map_input)
+        map_name = os.path.basename(map_path)
+
+        map_results[map_name] = validate_single_map(map_input)
+
+    return OrderedDict([
+        ("data_validation", OrderedDict([
+            ("map_data_validation", map_results)
+        ]))
+    ])

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137}/va/metrics/projections.py

@@ -183,7 +183,10 @@ class Projections:
     def _green_percentage(self, image_obj):
         """
         image_obj can be a file path, PIL Image, or numpy array.
-        Returns green percentage as a float.
+        Returns a dictionary with:
+          - percentage: total green percentage in the whole image
+          - diff_vertical: left-half green percentage minus right-half green percentage
+          - diff_horizontal: top-half green percentage minus bottom-half green percentage
         """
         if isinstance(image_obj, str):
             img = Image.open(image_obj).convert("RGB")
@@ -193,10 +196,43 @@ class Projections:
             img = Image.fromarray(image_obj).convert("RGB")
 
         img_array = np.array(img)
-        green_pixels = np.sum(np.all(img_array == [0, 138, 0], axis=-1))
-        total_pixels = img_array.shape[0] * img_array.shape[1]
-        proportion_green = (green_pixels / total_pixels) * 100 if total_pixels else 0.0
-        return round(proportion_green, 2)
+        green_mask = np.all(img_array == [0, 138, 0], axis=-1)
+        height, width = green_mask.shape
+        total_pixels = height * width
+        if total_pixels == 0:
+            return {
+                'percentage': 0.0,
+                'diff_vertical': 0.0,
+                'diff_horizontal': 0.0,
+            }
+
+        green_pixels = np.sum(green_mask)
+        proportion_green = (green_pixels / total_pixels) * 100
+
+        mid_vertical = width // 2
+        left_total = height * mid_vertical
+        right_total = height * (width - mid_vertical)
+        green_pixels_left_half = np.sum(green_mask[:, :mid_vertical])
+        green_pixels_right_half = np.sum(green_mask[:, mid_vertical:])
+        proportion_green_left_half = (green_pixels_left_half / left_total) * 100 if left_total else 0.0
+        proportion_green_right_half = (green_pixels_right_half / right_total) * 100 if right_total else 0.0
+        diff_vertical = proportion_green_left_half - proportion_green_right_half
+
+        mid_horizontal = height // 2
+        top_total = mid_horizontal * width
+        bottom_total = (height - mid_horizontal) * width
+        green_pixels_top_half = np.sum(green_mask[:mid_horizontal, :])
+        green_pixels_bottom_half = np.sum(green_mask[mid_horizontal:, :])
+        proportion_green_top_half = (green_pixels_top_half / top_total) * 100 if top_total else 0.0
+        proportion_green_bottom_half = (green_pixels_bottom_half / bottom_total) * 100 if bottom_total else 0.0
+        diff_horizontal = proportion_green_top_half - proportion_green_bottom_half
+
+        return {
+            'percentage': round(proportion_green, 2),
+            'diff_vertical': round(diff_vertical, 2),
+            'diff_horizontal': round(diff_horizontal, 2),
+        }
+
 
     def orthogonal_projections(self, mapin=None, workdir=None, type=None, label=''):
         map, workdir = self.mapincheck(mapin, workdir)

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137}/va/validationanalysis.py

@@ -77,6 +77,7 @@ from va.metrics.qscore import *
 from va.metrics.inclusion import *
 from va.metrics.connected_percentage import *
 from va.metrics.overlap_percentage import *
+from metrics.map_data_validation import run_map_data_validation
 import va
 
 try:
@@ -1158,6 +1159,48 @@ class ValidationAnalysis:
             viewer.new_surface_view_chimerax(primary_input_map, primary_input_contour, 'mask', '',
                                            mask_name, mask_contour)
 
+    @profile_peak_memory()
+    def map_data_validation(self):
+        """
+        Validate map/header data using mrcfile.validate().
+
+        Output JSON structure:
+            data_validation -> map_data_validation -> mapname -> validation results
+        """
+
+        start = timeit.default_timer()
+        map_inputs = []
+
+        for attr in ("map", "rawmap", "hmodd", "hmeven"):
+            try:
+                value = getattr(self, attr, None)
+                if value is not None:
+                    map_inputs.append(value)
+            except AttributeError:
+                pass
+
+        try:
+            result_dict = run_map_data_validation(map_inputs)
+
+            out_json = os.path.join(
+                self.workdir,
+                f"{self.mapname}_map_data_validation.json"
+            )
+
+            with codecs.open(out_json, "w", encoding="utf-8") as f:
+                json.dump(result_dict, f)
+
+            print("Map data validation results were collected.")
+
+        except:
+            err = "Map data validation error: {}.".format(sys.exc_info()[1])
+            sys.stderr.write(err + "\n")
+
+        end = timeit.default_timer()
+        print("Map data validation time: %s" % (end - start))
+        print("------------------------------------")
+
+        return None
 
     # Surface Chimera way
     # def new_surface_view_chimerax(self, input_map, input_contour, type='surface', raw='', mask_map=None,

{emdbva-0.0.1.dev135 → emdbva-0.0.1.dev137}/va/version.py

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