pytme 0.1.7__tar.gz → 0.1.8__tar.gz

{pytme-0.1.7 → pytme-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytme
-Version: 0.1.7
+Version: 0.1.8
 Summary: Python Template Matching Engine
 Author: Valentin Maurer
 Author-email: Valentin Maurer <valentin.maurer@embl-hamburg.de>
@@ -31,7 +31,7 @@ A software for template matching on electron microscopy data.
 
 ### Installation
 
-There are three ways to get PyTME up and running:
+There are three ways to get pyTME up and running:
 
 1. **Install from Source:**
 ```bash
@@ -44,7 +44,7 @@ pip install pytme
 ```
 
 3. **Docker Container:**
-Build and use the PyTME container from Docker. This assumes a linux/amd64 platform.
+Build and use the pyTME container from Docker. This assumes a linux/amd64 platform.
 ```bash
 docker build \
 	-t pytme \
@@ -58,12 +58,14 @@ docker build \
 
 ### Publication
 
-The pyTME publication is available on [bioRxiv](https://www.biorxiv.org/content/10.1101/2023.10.23.563472v1).
+The pyTME publication is available on [SoftwareX](https://www.sciencedirect.com/science/article/pii/S2352711024000074).
 
 ```
-@article{Maurer2023.10.23.563472,
-	author = {Valentin J. Maurer and Marc Siggel and Jan Kosinski},
-	journal = {bioRxiv},
+@article{Maurer:2024aa,
+	author = {Maurer, Valentin J. and Siggel, Marc and Kosinski, Jan},
+	journal = {SoftwareX},
+	pages = {101636},
 	title = {PyTME (Python Template Matching Engine): A fast, flexible, and multi-purpose template matching library for cryogenic electron microscopy data},
-	year = {2023}}
+	volume = {25},
+	year = {2024}}
 ```

{pytme-0.1.7 → pytme-0.1.8}/README.md

@@ -6,7 +6,7 @@ A software for template matching on electron microscopy data.
 
 ### Installation
 
-There are three ways to get PyTME up and running:
+There are three ways to get pyTME up and running:
 
 1. **Install from Source:**
 ```bash
@@ -19,7 +19,7 @@ pip install pytme
 ```
 
 3. **Docker Container:**
-Build and use the PyTME container from Docker. This assumes a linux/amd64 platform.
+Build and use the pyTME container from Docker. This assumes a linux/amd64 platform.
 ```bash
 docker build \
 	-t pytme \
@@ -33,12 +33,14 @@ docker build \
 
 ### Publication
 
-The pyTME publication is available on [bioRxiv](https://www.biorxiv.org/content/10.1101/2023.10.23.563472v1).
+The pyTME publication is available on [SoftwareX](https://www.sciencedirect.com/science/article/pii/S2352711024000074).
 
 ```
-@article{Maurer2023.10.23.563472,
-	author = {Valentin J. Maurer and Marc Siggel and Jan Kosinski},
-	journal = {bioRxiv},
+@article{Maurer:2024aa,
+	author = {Maurer, Valentin J. and Siggel, Marc and Kosinski, Jan},
+	journal = {SoftwareX},
+	pages = {101636},
 	title = {PyTME (Python Template Matching Engine): A fast, flexible, and multi-purpose template matching library for cryogenic electron microscopy data},
-	year = {2023}}
+	volume = {25},
+	year = {2024}}
 ```

{pytme-0.1.7 → pytme-0.1.8}/pyproject.toml

@@ -7,7 +7,7 @@ name="pytme"
 authors = [
   { name = "Valentin Maurer", email = "valentin.maurer@embl-hamburg.de" },
 ]
-version="0.1.7"
+version="0.1.8"
 description="Python Template Matching Engine"
 readme="README.md"
 requires-python = ">=3.11"

{pytme-0.1.7 → pytme-0.1.8}/scripts/match_template.py

@@ -539,15 +539,14 @@ def main():
         opening_axis, tilt_axis = [int(x) for x in args.wedge_axes.split(",")]
 
         if args.tilt_step is not None:
-            tilt_angles = np.arange(
-                -tilt_start, tilt_stop + args.tilt_step, args.tilt_step
-            )
-            angles = np.zeros((template.data.ndim, tilt_angles.size))
-            angles[tilt_axis, :] = tilt_angles
-            template_filter["wedge_mask"] = {
-                "tilt_angles": angles,
+            template_filter["step_wedge_mask"] = {
+                "start_tilt": tilt_start,
+                "stop_tilt": tilt_stop,
+                "tilt_step": args.tilt_step,
                 "sigma": args.wedge_smooth,
-                "opening_axes": opening_axis,
+                "opening_axis": opening_axis,
+                "tilt_axis": tilt_axis,
+                "omit_negative_frequencies": True,
             }
         else:
             template_filter["continuous_wedge_mask"] = {
@@ -557,6 +556,7 @@ def main():
                 "opening_axis": opening_axis,
                 "infinite_plane": True,
                 "sigma": args.wedge_smooth,
+                "omit_negative_frequencies": True,
             }
 
     if template_mask is None:
@@ -593,7 +593,9 @@ def main():
     print("\n" + "-" * 80)
 
     if args.scramble_phases:
-        template.data = scramble_phases(template.data, noise_proportion=1.0)
+        template.data = scramble_phases(
+            template.data, noise_proportion=1.0, normalize_power=True
+        )
 
     available_memory = backend.get_available_memory()
     if args.use_gpu:
@@ -671,7 +673,7 @@ def main():
         exit(-1)
 
     analyzer_args = {
-        "score_threshold": 0.0,
+        "score_threshold": 0,
         "number_of_peaks": 1000,
         "convolution_mode": "valid",
         "use_memmap": args.use_memmap,

{pytme-0.1.7 → pytme-0.1.8}/scripts/postprocess.py

@@ -15,6 +15,7 @@ from dataclasses import dataclass
 
 import numpy as np
 from scipy.spatial.transform import Rotation
+from numpy.typing import NDArray
 
 from tme import Density, Structure
 from tme.analyzer import (
@@ -28,6 +29,7 @@ from tme.matching_utils import (
     load_pickle,
     euler_to_rotationmatrix,
     euler_from_rotationmatrix,
+    centered_mask,
 )
 
 PEAK_CALLERS = {
@@ -75,6 +77,13 @@ def parse_args():
         help="Minimum distance from target boundaries. Ignored when --orientations "
         "is provided.",
     )
+    parser.add_argument(
+        "--mask_edges",
+        action="store_true",
+        default=False,
+        help="Whether to mask edges of the input score array according to the template shape."
+        "Uses twice the value of --min_boundary_distance if boht are provided.",
+    )
     parser.add_argument(
         "--wedge_mask",
         type=str,
@@ -403,11 +412,25 @@ class Orientations:
         return translation, rotation, score, detail
 
 
+def load_template(filepath: str, sampling_rate: NDArray) -> "Density":
+    try:
+        template = Density.from_file(filepath)
+        template, _ = template.centered(0)
+        center_of_mass = template.center_of_mass(template.data)
+    except ValueError:
+        template = Structure.from_file(filepath)
+        center_of_mass = template.center_of_mass()[::-1]
+        template = Density.from_structure(template, sampling_rate=sampling_rate)
+
+    return template, center_of_mass
+
+
 def main():
     args = parse_args()
     data = load_pickle(args.input_file)
 
     meta = data[-1]
+    target_origin, _, sampling_rate, cli_args = meta
 
     if args.orientations is not None:
         orientations = Orientations.from_file(
@@ -419,6 +442,17 @@ def main():
         # Output is MaxScoreOverRotations
         if data[0].ndim == data[2].ndim:
             scores, offset, rotation_array, rotation_mapping, meta = data
+            if args.mask_edges:
+                template, center_of_mass = load_template(
+                    cli_args.template, sampling_rate=sampling_rate
+                )
+                if not cli_args.no_centering:
+                    template, *_ = template.centered(0)
+                mask_size = template.shape
+                if args.min_boundary_distance > 0:
+                    mask_size = 2 * args.min_boundary_distance
+                scores = centered_mask(scores, np.subtract(scores.shape, mask_size) + 1)
+
             peak_caller = PEAK_CALLERS[args.peak_caller](
                 number_of_peaks=args.number_of_peaks,
                 min_distance=args.min_distance,
@@ -458,19 +492,11 @@ def main():
         orientations.to_file(filename=f"{args.output_prefix}.tsv", file_format="text")
         exit(0)
 
-    target_origin, _, sampling_rate, cli_args = meta
-
-    template_is_density, index = True, 0
     _, template_extension = splitext(cli_args.template)
-    try:
-        template = Density.from_file(cli_args.template)
-        template, _ = template.centered(0)
-        center_of_mass = template.center_of_mass(template.data)
-    except ValueError:
-        template_is_density = False
-        template = Structure.from_file(cli_args.template)
-        center_of_mass = template.center_of_mass()[::-1]
-        template = Density.from_structure(template, sampling_rate=sampling_rate)
+    template, center_of_mass = load_template(
+        filepath=cli_args.template, sampling_rate=sampling_rate
+    )
+    template_is_density, index = isinstance(template, Density), 0
 
     if args.output_format == "relion":
         new_shape = np.add(template.shape, np.mod(template.shape, 2))

{pytme-0.1.7 → pytme-0.1.8}/scripts/preprocessor_gui.py

@@ -29,17 +29,17 @@ preprocessor = Preprocessor()
 SLIDER_MIN, SLIDER_MAX = 0, 25
 
 
-def gaussian_filter(template, sigma: float, **kwargs: dict):
+def gaussian_filter(template: NDArray, sigma: float, **kwargs: dict) -> NDArray:
     return preprocessor.gaussian_filter(template=template, sigma=sigma, **kwargs)
 
 
 def bandpass_filter(
-    template,
+    template: NDArray,
     minimum_frequency: float,
     maximum_frequency: float,
     gaussian_sigma: float,
     **kwargs: dict,
-):
+) -> NDArray:
     return preprocessor.bandpass_filter(
         template=template,
         minimum_frequency=minimum_frequency,
@@ -51,8 +51,8 @@ def bandpass_filter(
 
 
 def difference_of_gaussian_filter(
-    template, sigmas: Tuple[float, float], **kwargs: dict
-):
+    template: NDArray, sigmas: Tuple[float, float], **kwargs: dict
+) -> NDArray:
     low_sigma, high_sigma = sigmas
     return preprocessor.difference_of_gaussian_filter(
         template=template, low_sigma=low_sigma, high_sigma=high_sigma, **kwargs
@@ -60,7 +60,7 @@ def difference_of_gaussian_filter(
 
 
 def edge_gaussian_filter(
-    template,
+    template: NDArray,
     sigma: float,
     edge_algorithm: Annotated[
         str,
@@ -68,7 +68,7 @@ def edge_gaussian_filter(
     ],
     reverse: bool = False,
     **kwargs: dict,
-):
+) -> NDArray:
     return preprocessor.edge_gaussian_filter(
         template=template,
         sigma=sigma,
@@ -78,13 +78,13 @@ def edge_gaussian_filter(
 
 
 def local_gaussian_filter(
-    template,
+    template: NDArray,
     lbd: float,
     sigma_range: Tuple[float, float],
     gaussian_sigma: float,
     reverse: bool = False,
     **kwargs: dict,
-):
+) -> NDArray:
     return preprocessor.local_gaussian_filter(
         template=template,
         lbd=lbd,
@@ -94,22 +94,30 @@ def local_gaussian_filter(
 
 
 def ntree(
-    template,
+    template: NDArray,
     sigma_range: Tuple[float, float],
     **kwargs: dict,
-):
+) -> NDArray:
     return preprocessor.ntree_filter(template=template, sigma_range=sigma_range)
 
 
 def mean(
-    template,
+    template: NDArray,
     width: int,
     **kwargs: dict,
-):
+) -> NDArray:
     return preprocessor.mean_filter(template=template, width=width)
 
 
-def resolution_sphere(template: NDArray, cutoff_angstrom: float, highpass : bool = False, sampling_rate = None):
+def resolution_sphere(
+    template: NDArray,
+    cutoff_angstrom: float,
+    highpass: bool = False,
+    sampling_rate=None,
+) -> NDArray:
+    if cutoff_angstrom == 0:
+        return template
+
     cutoff_frequency = np.max(2 * sampling_rate / cutoff_angstrom)
 
     min_freq, max_freq = 0, cutoff_frequency
@@ -123,34 +131,39 @@ def resolution_sphere(template: NDArray, cutoff_angstrom: float, highpass : bool
         omit_negative_frequencies=False,
     )
 
-    mask = np.fft.ifftshift(mask)
     template_ft = np.fft.fftn(template)
-    np.multiply(template_ft, mask, out = template_ft)
-
+    np.multiply(template_ft, mask, out=template_ft)
     return np.fft.ifftn(template_ft).real
 
 
-def resolution_gaussian(template : NDArray, cutoff_angstrom : float, highpass : bool = False,
-    sampling_rate = None):
+def resolution_gaussian(
+    template: NDArray,
+    cutoff_angstrom: float,
+    highpass: bool = False,
+    sampling_rate=None,
+) -> NDArray:
+    if cutoff_angstrom == 0:
+        return template
+
     grid = preprocessor.fftfreqn(
-        shape = template.shape, sampling_rate = sampling_rate / sampling_rate.max()
+        shape=template.shape, sampling_rate=sampling_rate / sampling_rate.max()
     )
 
     sigma_fourier = np.divide(
-        np.max(2 * sampling_rate / cutoff_angstrom),
-        np.sqrt(2 * np.log(2))
+        np.max(2 * sampling_rate / cutoff_angstrom), np.sqrt(2 * np.log(2))
     )
 
-    mask = np.exp(-grid ** 2 / (2 * sigma_fourier ** 2))
+    mask = np.exp(-(grid**2) / (2 * sigma_fourier**2))
     if highpass:
         mask = 1 - mask
 
     mask = np.fft.ifftshift(mask)
-    template_ft = np.fft.fftn(template)
-    np.multiply(template_ft, mask, out = template_ft)
 
+    template_ft = np.fft.fftn(template)
+    np.multiply(template_ft, mask, out=template_ft)
     return np.fft.ifftn(template_ft).real
 
+
 def wedge(
     template: NDArray,
     tilt_start: float,
@@ -162,7 +175,7 @@ def wedge(
     omit_negative_frequencies: bool = True,
     extrude_plane: bool = True,
     infinite_plane: bool = True,
-):
+) -> NDArray:
     template_ft = np.fft.rfftn(template)
 
     if tilt_step <= 0:
@@ -181,15 +194,14 @@ def wedge(
         template = np.real(np.fft.irfftn(template_ft))
         return template
 
-    tilt_angles = np.arange(-tilt_start, tilt_stop, tilt_step)
-    angles = np.zeros((template.ndim, tilt_angles.size))
-    angles[tilt_axis, :] = tilt_angles
-
-    wedge_mask = preprocessor.wedge_mask(
-        tilt_angles=angles,
+    wedge_mask = preprocessor.step_wedge_mask(
+        start_tilt=tilt_start,
+        stop_tilt=tilt_stop,
+        tilt_axis=tilt_axis,
+        tilt_step=tilt_step,
+        opening_axis=opening_axis,
         shape=template.shape,
         sigma=gaussian_sigma,
-        opening_axes=opening_axis,
         omit_negative_frequencies=omit_negative_frequencies,
     )
     np.multiply(template_ft, wedge_mask, out=template_ft)
@@ -197,7 +209,7 @@ def wedge(
     return template
 
 
-def compute_power_spectrum(template: NDArray):
+def compute_power_spectrum(template: NDArray) -> NDArray:
     return np.fft.fftshift(np.log(np.abs(np.fft.fftn(template))))
 
 
@@ -262,8 +274,8 @@ WRAPPED_FUNCTIONS = {
     "mean_filter": mean,
     "wedge_filter": wedge,
     "power_spectrum": compute_power_spectrum,
-    "resolution_gaussian" : resolution_gaussian,
-    "resolution_sphere" : resolution_sphere,
+    "resolution_gaussian": resolution_gaussian,
+    "resolution_sphere": resolution_sphere,
 }
 
 EXCLUDED_FUNCTIONS = [
@@ -405,7 +417,7 @@ class FilterWidget(widgets.Container):
 
 def sphere_mask(
     template: NDArray, center_x: float, center_y: float, center_z: float, radius: float
-):
+) -> NDArray:
     return create_mask(
         mask_type="ellipse",
         shape=template.shape,
@@ -422,7 +434,7 @@ def ellipsod_mask(
     radius_x: float,
     radius_y: float,
     radius_z: float,
-):
+) -> NDArray:
     return create_mask(
         mask_type="ellipse",
         shape=template.shape,
@@ -439,7 +451,7 @@ def box_mask(
     height_x: int,
     height_y: int,
     height_z: int,
-):
+) -> NDArray:
     return create_mask(
         mask_type="box",
         shape=template.shape,
@@ -457,7 +469,7 @@ def tube_mask(
     inner_radius: float,
     outer_radius: float,
     height: int,
-):
+) -> NDArray:
     return create_mask(
         mask_type="tube",
         shape=template.shape,
@@ -480,7 +492,7 @@ def wedge_mask(
     omit_negative_frequencies: bool = False,
     extrude_plane: bool = True,
     infinite_plane: bool = True,
-):
+) -> NDArray:
     if tilt_step <= 0:
         wedge_mask = preprocessor.continuous_wedge_mask(
             start_tilt=tilt_start,
@@ -496,25 +508,24 @@ def wedge_mask(
         wedge_mask = np.fft.fftshift(wedge_mask)
         return wedge_mask
 
-    tilt_angles = np.arange(-tilt_start, tilt_stop + tilt_step, tilt_step)
-    angles = np.zeros((template.ndim, tilt_angles.size))
-
-    angles[tilt_axis, :] = tilt_angles
-
-    wedge_mask = preprocessor.wedge_mask(
-        tilt_angles=angles,
+    wedge_mask = preprocessor.step_wedge_mask(
+        start_tilt=tilt_start,
+        stop_tilt=tilt_stop,
+        tilt_axis=tilt_axis,
+        tilt_step=tilt_step,
+        opening_axis=opening_axis,
         shape=template.shape,
         sigma=gaussian_sigma,
-        opening_axes=opening_axis,
         omit_negative_frequencies=omit_negative_frequencies,
     )
+
     wedge_mask = np.fft.fftshift(wedge_mask)
     return wedge_mask
 
 
 def threshold_mask(
     template: NDArray, standard_deviation: float = 5.0, invert: bool = False
-):
+) -> NDArray:
     template_mean = template.mean()
     template_deviation = standard_deviation * template.std()
     upper = template_mean + template_deviation
@@ -526,6 +537,15 @@ def threshold_mask(
     return mask
 
 
+def lowpass_mask(template: NDArray, sigma: float = 1.0):
+    template = template / template.max()
+    template = (template > np.exp(-2)) * 128.0
+    template = preprocessor.gaussian_filter(template=template, sigma=sigma)
+    mask = template > np.exp(-2)
+
+    return mask
+
+
 class MaskWidget(widgets.Container):
     def __init__(self, viewer):
         super().__init__(layout="vertical")
@@ -543,6 +563,7 @@ class MaskWidget(widgets.Container):
             "Box": box_mask,
             "Wedge": wedge_mask,
             "Threshold": threshold_mask,
+            "Lowpass": lowpass_mask,
         }
 
         self.method_dropdown = widgets.ComboBox(
@@ -606,6 +627,7 @@ class MaskWidget(widgets.Container):
             arr=active_layer.data,
             rotation_matrix=rotation_matrix,
             use_geometric_center=False,
+            order=1,
         )
         eps = np.finfo(rotated_data.dtype).eps
         rotated_data[rotated_data < eps] = 0
@@ -636,10 +658,10 @@ class MaskWidget(widgets.Container):
             dict(zip(["height_x", "height_y", "height_z"], coordinates_heights))
         )
 
-        defaults["radius"] = np.min(coordinate_radius)
+        defaults["radius"] = np.max(coordinate_radius)
         defaults["inner_radius"] = np.min(coordinate_radius)
         defaults["outer_radius"] = np.max(coordinate_radius)
-        defaults["height"] = defaults["radius"]
+        defaults["height"] = np.max(coordinates_heights)
 
         for widget in self.action_widgets:
             if widget.name in defaults:

pytme-0.1.8/tme/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.8"

{pytme-0.1.7 → pytme-0.1.8}/tme/backends/npfftw_backend.py

@@ -613,13 +613,6 @@ class NumpyFFTWBackend(MatchingBackend):
         rotate_mask = arr_mask is not None and mask_coordinates is not None
         return_type = (out is None) + 2 * rotate_mask * (out_mask is None)
 
-        # Otherwise array might be slightly shifted by centering
-        if np.allclose(
-            rotation_matrix,
-            np.eye(rotation_matrix.shape[0], dtype=rotation_matrix.dtype),
-        ):
-            center_rotation = False
-
         coordinates_rotated = np.empty(coordinates.shape, dtype=rotation_matrix.dtype)
         mask_rotated = (
             np.empty(mask_coordinates.shape, dtype=rotation_matrix.dtype)

{pytme-0.1.7 → pytme-0.1.8}/tme/density.py

@@ -199,16 +199,16 @@ class Density:
             func = cls._load_mrc
             if filename.endswith(".em") or filename.endswith(".em.gz"):
                 func = cls._load_em
-            data, origin, sampling_rate = func(
+            data, origin, sampling_rate, meta = func(
                 filename=filename, subset=subset, use_memmap=use_memmap
             )
         except ValueError:
-            data, origin, sampling_rate = cls._load_skio(filename=filename)
+            data, origin, sampling_rate, meta = cls._load_skio(filename=filename)
             if subset is not None:
                 cls._validate_slices(slices=subset, shape=data.shape)
                 data = data[subset].copy()
 
-        return cls(data=data, origin=origin, sampling_rate=sampling_rate)
+        return cls(data=data, origin=origin, sampling_rate=sampling_rate, metadata=meta)
 
     @classmethod
     def _load_mrc(
@@ -307,6 +307,13 @@ class Density:
 
             extended_header = mrc.header.nsymbt
 
+            metadata = {
+                "min": float(mrc.header.dmin),
+                "max": float(mrc.header.dmax),
+                "mean": float(mrc.header.dmean),
+                "std": float(mrc.header.rms),
+            }
+
         if is_gzipped(filename):
             if use_memmap:
                 warnings.warn(
@@ -329,7 +336,7 @@ class Density:
                 dtype=data_type,
                 header_size=1024 + extended_header,
             )
-            return data, origin, sampling_rate
+            return data, origin, sampling_rate, metadata
 
         if not use_memmap:
             with mrcfile.open(filename, header_only=False) as mrc:
@@ -343,7 +350,7 @@ class Density:
             data = np.transpose(data, crs_index)
             start = np.take(start, crs_index)
 
-        return data, origin, sampling_rate
+        return data, origin, sampling_rate, metadata
 
     @classmethod
     def _load_em(
@@ -448,7 +455,7 @@ class Density:
             pixel_size = 1
         sampling_rate = np.repeat(pixel_size, data.ndim).astype(data.dtype)
 
-        return data, origin, sampling_rate
+        return data, origin, sampling_rate, {}
 
     @staticmethod
     def _validate_slices(slices: Tuple[slice], shape: Tuple[int]):
@@ -592,7 +599,7 @@ class Density:
         warnings.warn(
             "origin and sampling_rate are not yet extracted from non CCP4/MRC files."
         )
-        return data, np.zeros(data.ndim), np.ones(data.ndim)
+        return data, np.zeros(data.ndim), np.ones(data.ndim), {}
 
     @classmethod
     def from_structure(
@@ -909,7 +916,8 @@ class Density:
         Returns a copy of the current class instance with all elements in
         :py:attr:`Density.data` set to zero. :py:attr:`Density.origin` and
         :py:attr:`Density.sampling_rate` will be copied, while
-        :py:attr:`Density.metadata` will be initialized to an empty dictionary.
+        :py:attr:`Density.metadata` will be initialized to contain min, max,
+        mean and standard deviation of :py:attr:`Density.data`.
 
         Examples
         --------
@@ -924,6 +932,7 @@ class Density:
             data=np.zeros_like(self.data),
             origin=deepcopy(self.origin),
             sampling_rate=deepcopy(self.sampling_rate),
+            metadata={"min": 0, "max": 0, "mean": 0, "std": 0},
         )
 
     def copy(self) -> "Density":