pytme 0.3b0.post1__tar.gz → 0.3.1.post1__tar.gz

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytme
-Version: 0.3b0.post1
+Version: 0.3.1.post1
 Summary: Python Template Matching Engine
 Author: Valentin Maurer
 Author-email: Valentin Maurer <valentin.maurer@embl-hamburg.de>
@@ -25,10 +25,8 @@ Requires-Dist: h5py
 Requires-Dist: importlib_resources
 Requires-Dist: joblib
 Provides-Extra: cupy
-Requires-Dist: cupy-cuda12x>=13.0.0; extra == "cupy"
-Provides-Extra: cupy-voltools
-Requires-Dist: cupy-cuda12x>=13.0.0; extra == "cupy-voltools"
-Requires-Dist: voltools; extra == "cupy-voltools"
+Requires-Dist: cupy-cuda12x>13.0.0; extra == "cupy"
+Requires-Dist: voltools; extra == "cupy"
 Provides-Extra: pytorch
 Requires-Dist: torch; extra == "pytorch"
 Requires-Dist: torchvision; extra == "pytorch"
@@ -77,8 +75,8 @@ You can find alternative installation methods in the [documentation](https://kos
 
 Learn how to get started with
 
-- [Installation:](https://kosinskilab.github.io/pyTME/quickstart/installation.html).
-- [Template matching:](https://kosinskilab.github.io/pyTME/quickstart/matching/particle_picking.html) Find your template of interest.
+- [Installation](https://kosinskilab.github.io/pyTME/quickstart/installation.html)
+- [Template matching](https://kosinskilab.github.io/pyTME/quickstart/matching/particle_picking.html) Find your template of interest.
 - [Postprocessing](https://kosinskilab.github.io/pyTME/quickstart/postprocessing/motivation.html) Analyze template matching results and downstream integrations.
 
 ## How to Cite

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/README.md

@@ -32,8 +32,8 @@ You can find alternative installation methods in the [documentation](https://kos
 
 Learn how to get started with
 
-- [Installation:](https://kosinskilab.github.io/pyTME/quickstart/installation.html).
-- [Template matching:](https://kosinskilab.github.io/pyTME/quickstart/matching/particle_picking.html) Find your template of interest.
+- [Installation](https://kosinskilab.github.io/pyTME/quickstart/installation.html)
+- [Template matching](https://kosinskilab.github.io/pyTME/quickstart/matching/particle_picking.html) Find your template of interest.
 - [Postprocessing](https://kosinskilab.github.io/pyTME/quickstart/postprocessing/motivation.html) Analyze template matching results and downstream integrations.
 
 ## How to Cite

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/pyproject.toml

@@ -7,7 +7,7 @@ name="pytme"
 authors = [
   { name = "Valentin Maurer", email = "valentin.maurer@embl-hamburg.de" },
 ]
-version="0.3.b0.post1"
+version="0.3.1.post1"
 description="Python Template Matching Engine"
 readme="README.md"
 requires-python = ">=3.11"
@@ -33,8 +33,7 @@ classifiers = [
 ]
 
 [project.optional-dependencies]
-cupy = ["cupy-cuda12x>=13.0.0"]
-cupy_voltools = ["cupy-cuda12x>=13.0.0", "voltools"]
+cupy = ["cupy-cuda12x>13.0.0", "voltools"]
 pytorch = ["torch", "torchvision"]
 jax = ["jax[cuda12]", "jaxlib"]
 jax_cpu = ["jax", "jaxlib"]

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/pytme.egg-info/SOURCES.txt

@@ -29,7 +29,9 @@ tests/test_orientations.py
 tests/test_parser.py
 tests/test_rotations.py
 tests/test_structure.py
+tests/data/.DS_Store
 tests/data/README.md
+tests/data/Blurring/.DS_Store
 tests/data/Blurring/blob_width18.npy
 tests/data/Blurring/edgegaussian_sigma3.npy
 tests/data/Blurring/gaussian_sigma2.npy
@@ -39,8 +41,11 @@ tests/data/Blurring/localgaussian_sigma0510.npy
 tests/data/Blurring/mean_size5.npy
 tests/data/Blurring/ntree_sigma0510.npy
 tests/data/Blurring/rank_rank3.npy
+tests/data/Maps/.DS_Store
 tests/data/Maps/emd_8621.mrc.gz
+tests/data/Raw/.DS_Store
 tests/data/Raw/em_map.map
+tests/data/Structures/.DS_Store
 tests/data/Structures/1pdj.cif
 tests/data/Structures/1pdj.pdb
 tests/data/Structures/5khe.cif
@@ -56,6 +61,7 @@ tme/__init__.py
 tme/__version__.py
 tme/cli.py
 tme/density.py
+tme/mask.py
 tme/matching_data.py
 tme/matching_exhaustive.py
 tme/matching_optimization.py
@@ -77,6 +83,7 @@ tme/analyzer/proxy.py
 tme/backends/__init__.py
 tme/backends/_cupy_utils.py
 tme/backends/_jax_utils.py
+tme/backends/_numpyfftw_utils.py
 tme/backends/cupy_backend.py
 tme/backends/jax_backend.py
 tme/backends/matching_backend.py

pytme-0.3.1.post1/scripts/extract_candidates.py

@@ -0,0 +1,243 @@
+#!python3
+"""Prepare orientations stack for refinement.
+
+Copyright (c) 2023 European Molecular Biology Laboratory
+
+Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
+"""
+import argparse
+from os import unlink
+from os.path import splitext, basename
+
+import numpy as np
+from collections import defaultdict
+
+from tme.parser import StarParser
+from tme import Density, Orientations
+from tme.matching_utils import generate_tempfile_name
+from tme.rotations import (
+    align_vectors,
+    euler_from_rotationmatrix,
+    euler_to_rotationmatrix,
+)
+
+
+class ProgressBar:
+    """
+    ASCII progress bar.
+    """
+
+    def __init__(self, message: str, nchars: int, total: int):
+        self._size = nchars - len(message) - (len(str(total)) + 2) * 2
+        self._message = message
+        self._total = total
+
+    def update(self, cur):
+        x = int(cur * self._size / self._total)
+        print(
+            "%s[%s%s] %i/%i\r"
+            % (self._message, "#" * x, "." * (self._size - x), cur, self._total),
+            end="",
+        )
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Extract matching candidates for further refinement.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    io_group = parser.add_argument_group("Input / Output")
+    io_group.add_argument(
+        "--orientations",
+        required=True,
+        type=str,
+        help="Star file with picks and micrograph names.",
+    )
+    io_group.add_argument(
+        "--orientations-scaling",
+        required=False,
+        type=float,
+        default=1.0,
+        help="Factor to map candidate coordinates onto the target. Only relevant if "
+        "target sampling rate differs from candidate orientation sampling rate.",
+    )
+    io_group.add_argument(
+        "-o",
+        "--output-prefix",
+        required=True,
+        type=str,
+        help="Output prefix to use.",
+    )
+
+    alignment_group = parser.add_argument_group("Alignment")
+    alignment_group.add_argument(
+        "--align-orientations",
+        action="store_true",
+        required=False,
+        help="Whether to align extracted orientations based on their angles. Allows "
+        "for efficient subsequent sampling of cone angles.",
+    )
+    alignment_group.add_argument(
+        "--angles-are-vector",
+        action="store_true",
+        required=False,
+        help="Considers euler_z euler_y, euler_x as vector that will be rotated to align "
+        "with the z-axis (1,0,0). Only considered when --align_orientations is set.",
+    )
+    alignment_group.add_argument(
+        "--interpolation-order",
+        required=False,
+        type=int,
+        default=1,
+        help="Interpolation order for alignment, less than zero is no interpolation.",
+    )
+    alignment_group.add_argument(
+        "--split-by-micrograph",
+        action="store_true",
+        required=False,
+        help="Create separate output files for each micrograph."
+    )
+
+    extraction_group = parser.add_argument_group("Extraction")
+    extraction_group.add_argument(
+        "--box-size",
+        required=True,
+        type=int,
+        help="Box size for extraction.",
+    )
+    extraction_group.add_argument(
+        "--translation-uncertainty",
+        required=False,
+        type=int,
+        help="Sets box size for extraction to template box plus this value.",
+    )
+    extraction_group.add_argument(
+        "--drop-out-of-box",
+        action="store_true",
+        required=False,
+        help="Whether to drop orientations that fall outside the box. If the "
+        "orientations are sensible, it is safe to pass this flag.",
+    )
+
+    args = parser.parse_args()
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    data = StarParser(args.orientations, delimiter="\t")
+    key = list(data.keys())[0]
+
+    index_map = defaultdict(list)
+    for index, value in enumerate(data[key]["_rlnMicrographName"]):
+        index_map[value].append(index)
+
+    orientations = Orientations.from_file(args.orientations)
+    orientations.translations = np.divide(
+        orientations.translations, args.orientations_scaling
+    )
+
+    box_size = np.array(args.box_size)
+    box_size = np.repeat(box_size, 3 // box_size.size).astype(int)
+    extraction_shape = np.copy(box_size)
+
+    if args.align_orientations:
+        extraction_shape[:] = int(np.linalg.norm(box_size) + 1)
+        for index in range(orientations.rotations.shape[0]):
+            rotation_matrix = euler_to_rotationmatrix(orientations.rotations[index])
+            rotation_matrix = np.linalg.inv(rotation_matrix)
+            if args.angles_are_vector:
+                rotation_matrix = align_vectors(
+                    orientations.rotations[index], target_vector=(1, 0, 0)
+                )
+            orientations.rotations[index] = euler_from_rotationmatrix(rotation_matrix)
+
+    ret_orientations, ret_dens, ix = [], [], 0
+    n_particles = orientations.translations.shape[0]
+    pbar = ProgressBar(message="Processing ", nchars=80, total=n_particles)
+    for target_path, indices in index_map.items():
+
+        target = Density.from_file(target_path, use_memmap=True)
+
+        subset = orientations[indices]
+        subset, cand_slices, obs_slices = subset.get_extraction_slices(
+            target_shape=target.shape,
+            extraction_shape=extraction_shape,
+            drop_out_of_box=args.drop_out_of_box,
+            return_orientations=True,
+        )
+
+        dens = Density(
+            np.memmap(
+                generate_tempfile_name(),
+                mode="w+",
+                shape=(subset.translations.shape[0], *box_size),
+                dtype=np.float32,
+            ),
+            sampling_rate = (1, *target.sampling_rate),
+            metadata = {"batch_dimension" : (0,), "path" : target_path}
+        )
+
+        data_subset = np.zeros(extraction_shape, dtype=target.data.dtype)
+        for index, (obs_slice, cand_slice) in enumerate(zip(obs_slices, cand_slices)):
+            pbar.update(ix + 1)
+
+            data_subset.fill(0)
+            data_subset[cand_slice] = target.data[obs_slice]
+            target_subset = Density(
+                data_subset,
+                sampling_rate=target.sampling_rate,
+                origin=target.origin,
+            )
+
+            if args.align_orientations:
+                rotation_matrix = euler_to_rotationmatrix(subset.rotations[index])
+                target_subset = target_subset.rigid_transform(
+                    rotation_matrix=rotation_matrix,
+                    use_geometric_center=True,
+                    order=args.interpolation_order,
+                )
+            target_subset.pad(box_size, center=True)
+            dens.data[index] = target_subset.data.astype(np.float32)
+            ix += 1
+
+        ret_dens.append(dens)
+        ret_orientations.append(subset)
+
+    if not len(ret_dens):
+        exit("Found no valid particles.")
+
+    print("")
+    if not args.split_by_micrograph:
+        ret_orientations = [Orientations(
+            translations=np.concatenate([x.translations for x in ret_orientations]),
+            rotations=np.concatenate([x.rotations for x in ret_orientations]),
+            scores=np.concatenate([x.scores for x in ret_orientations]),
+            details=np.concatenate([x.details for x in ret_orientations]),
+        )]
+        dens_data = Density(
+            np.concatenate([x.data for x in ret_dens]),
+            sampling_rate=ret_dens[0].sampling_rate
+        )
+        _ = [unlink(x.data.filename) for x in ret_dens]
+        dens_data.metadata.update({"batch_dimension" : (0, )})
+        ret_dens = [dens_data]
+
+    for orientation, dens in zip(ret_orientations, ret_dens):
+        fname = args.output_prefix
+        if args.split_by_micrograph:
+            target = splitext(basename(dens.metadata["path"]))[0]
+            fname = f"{args.output_prefix}_{target}"
+
+        dens.to_file(f"{fname}.h5")
+        orientation.to_file(f"{fname}_aligned.star")
+        try:
+            unlink(dens.data.filename)
+        except Exception:
+            continue
+
+if __name__ == "__main__":
+    main()

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/scripts/match_template.py

@@ -12,8 +12,8 @@ from sys import exit
 from time import time
 from typing import Tuple
 from copy import deepcopy
-from os.path import exists
 from tempfile import gettempdir
+from os.path import exists, abspath
 
 import numpy as np
 
@@ -576,7 +576,7 @@ def parse_args():
         "'angles', or a single column file without header. Exposure will be taken from "
         "the input file , if you are using a tab-separated file, the column names "
         "'angles' and 'weights' need to be present. It is also possible to specify a "
-        "continuous wedge mask using e.g., -50,45.",
+        "continuous wedge mask using e.g., 50,45.",
     )
     filter_group.add_argument(
         "--tilt-weighting",
@@ -685,13 +685,6 @@ def parse_args():
         help="Useful if the target does not have a well-defined bounding box. Will be "
         "activated automatically if splitting is required to avoid boundary artifacts.",
     )
-    performance_group.add_argument(
-        "--pad-filter",
-        action="store_true",
-        default=False,
-        help="Pad the template filter to the shape of the target. Useful for fast "
-        "oscilating filters to avoid aliasing effects.",
-    )
     performance_group.add_argument(
         "--interpolation-order",
         required=False,
@@ -700,13 +693,6 @@ def parse_args():
         help="Spline interpolation used for rotations. Defaults to 3, and 1 for jax "
         "and pytorch backends.",
     )
-    performance_group.add_argument(
-        "--use-mixed-precision",
-        action="store_true",
-        default=False,
-        help="Use float16 for real values operations where possible. Not supported "
-        "for jax backend.",
-    )
     performance_group.add_argument(
         "--use-memmap",
         action="store_true",
@@ -742,6 +728,7 @@ def parse_args():
         args.interpolation_order = 3
         if args.backend in ("jax", "pytorch"):
             args.interpolation_order = 1
+            args.reconstruction_interpolation_order = 1
 
     if args.interpolation_order < 0:
         args.interpolation_order = None
@@ -779,6 +766,14 @@ def parse_args():
         )
         args.orientations = orientations
 
+    args.target = abspath(args.target)
+    if args.target_mask is not None:
+        args.target_mask = abspath(args.target_mask)
+
+    args.template = abspath(args.template)
+    if args.template_mask is not None:
+        args.template_mask = abspath(args.template_mask)
+
     return args
 
 
@@ -796,15 +791,23 @@ def main():
             sampling_rate=target.sampling_rate,
         )
 
+    if np.allclose(target.sampling_rate, 1):
+        warnings.warn(
+            "Target sampling rate is 1.0, which may indicate missing or incorrect "
+            "metadata. Verify that your target file contains proper sampling rate "
+            "information, as filters (CTF, BandPass) require accurate sampling rates "
+            "to function correctly."
+        )
+
     if target.sampling_rate.size == template.sampling_rate.size:
         if not np.allclose(
             np.round(target.sampling_rate, 2), np.round(template.sampling_rate, 2)
         ):
-            print(
-                f"Resampling template to {target.sampling_rate}. "
-                "Consider providing a template with the same sampling rate as the target."
+            warnings.warn(
+                f"Sampling rate mismatch detected: target={target.sampling_rate} "
+                f"template={template.sampling_rate}. Proceeding with user-provided "
+                f"values. Make sure this is intentional. "
             )
-            template = template.resample(target.sampling_rate, order=3)
 
     template_mask = load_and_validate_mask(
         mask_target=template, mask_path=args.template_mask
@@ -881,16 +884,13 @@ def main():
     print("\n" + "-" * 80)
 
     if args.scramble_phases:
-        template.data = scramble_phases(
-            template.data, noise_proportion=1.0, normalize_power=False
-        )
+        template.data = scramble_phases(template.data, noise_proportion=1.0)
 
     callback_class = MaxScoreOverRotations
-    if args.peak_calling:
-        callback_class = PeakCallerMaximumFilter
-
     if args.orientations is not None:
         callback_class = MaxScoreOverRotationsConstrained
+    elif args.peak_calling:
+        callback_class = PeakCallerMaximumFilter
 
     # Determine suitable backend for the selected operation
     available_backends = be.available_backends()
@@ -939,16 +939,6 @@ def main():
             args.use_gpu = False
             be.change_backend("pytorch", device=device)
 
-    # TODO: Make the inverse casting from complex64 -> float 16 stable
-    # if args.use_mixed_precision:
-    #     be.change_backend(
-    #         backend_name=args.backend,
-    #         float_dtype=be._array_backend.float16,
-    #         complex_dtype=be._array_backend.complex64,
-    #         int_dtype=be._array_backend.int16,
-    #         device=device,
-    #     )
-
     available_memory = be.get_available_memory() * be.device_count()
     if args.memory is None:
         args.memory = int(args.memory_scaling * available_memory)
@@ -976,6 +966,8 @@ def main():
         target_dim=target.metadata.get("batch_dimension", None),
         template_dim=template.metadata.get("batch_dimension", None),
     )
+    args.batch_dims = tuple(int(x) for x in np.where(matching_data._batch_mask)[0])
+
     splits, schedule = compute_schedule(args, matching_data, callback_class)
 
     n_splits = np.prod(list(splits.values()))
@@ -1004,7 +996,6 @@ def main():
     compute_options = {
         "Backend": be._BACKEND_REGISTRY[be._backend_name],
         "Compute Devices": f"CPU [{args.cores}], GPU [{gpus_used}]",
-        "Use Mixed Precision": args.use_mixed_precision,
         "Assigned Memory [MB]": f"{args.memory // 1e6} [out of {available_memory//1e6}]",
         "Temporary Directory": args.temp_directory,
         "Target Splits": f"{target_split} [N={n_splits}]",
@@ -1025,7 +1016,6 @@ def main():
         "Tilt Angles": args.tilt_angles,
         "Tilt Weighting": args.tilt_weighting,
         "Reconstruction Filter": args.reconstruction_filter,
-        "Extend Filter Grid": args.pad_filter,
     }
     if args.ctf_file is not None or args.defocus is not None:
         filter_args["CTF File"] = args.ctf_file
@@ -1081,7 +1071,6 @@ def main():
         callback_class_args=analyzer_args,
         target_splits=splits,
         pad_target_edges=args.pad_edges,
-        pad_template_filter=args.pad_filter,
         interpolation_order=args.interpolation_order,
     )
 

{pytme-0.3b0.post1 → pytme-0.3.1.post1}/scripts/postprocess.py

@@ -17,7 +17,7 @@ from scipy.special import erfcinv
 
 from tme import Density, Structure, Orientations
 from tme.cli import sanitize_name, print_block, print_entry
-from tme.matching_utils import load_pickle, centered_mask, write_pickle
+from tme.matching_utils import load_pickle, center_slice, write_pickle
 from tme.matching_optimization import create_score_object, optimize_match
 from tme.rotations import euler_to_rotationmatrix, euler_from_rotationmatrix
 from tme.analyzer import (
@@ -87,6 +87,11 @@ def parse_args():
         help="Output prefix. Defaults to basename of first input. Extension is "
         "added with respect to chosen output format.",
     )
+    output_group.add_argument(
+        "--angles-clockwise",
+        action="store_true",
+        help="Report Euler angles in clockwise format expected by RELION.",
+    )
     output_group.add_argument(
         "--output-format",
         choices=[
@@ -112,7 +117,7 @@ def parse_args():
     peak_group.add_argument(
         "--peak-caller",
         choices=list(PEAK_CALLERS.keys()),
-        default="PeakCallerScipy",
+        default="PeakCallerMaximumFilter",
         help="Peak caller for local maxima identification.",
     )
     peak_group.add_argument(
@@ -183,7 +188,7 @@ def parse_args():
     )
     additional_group.add_argument(
         "--n-false-positives",
-        type=int,
+        type=float,
         default=None,
         required=False,
         help="Number of accepted false-positives picks to determine minimum score.",
@@ -313,11 +318,7 @@ def normalize_input(foregrounds: Tuple[str], backgrounds: Tuple[str]) -> Tuple:
         data = load_matching_output(foreground)
         scores, _, rotations, rotation_mapping, *_ = data
 
-        # We could normalize to unit sdev, but that might lead to unexpected
-        # results for flat background distributions
-        scores -= scores.mean()
         indices = tuple(slice(0, x) for x in scores.shape)
-
         indices_update = scores > scores_out[indices]
         scores_out[indices][indices_update] = scores[indices_update]
 
@@ -364,9 +365,8 @@ def normalize_input(foregrounds: Tuple[str], backgrounds: Tuple[str]) -> Tuple:
     scores_norm = np.full(out_shape_norm, fill_value=0, dtype=np.float32)
     for background in backgrounds:
         data_norm = load_matching_output(background)
+        scores, _, rotations, rotation_mapping, *_ = data_norm
 
-        scores = data_norm[0]
-        scores -= scores.mean()
         indices = tuple(slice(0, x) for x in scores.shape)
         indices_update = scores > scores_norm[indices]
         scores_norm[indices][indices_update] = scores[indices_update]
@@ -375,7 +375,9 @@ def normalize_input(foregrounds: Tuple[str], backgrounds: Tuple[str]) -> Tuple:
     update = tuple(slice(0, int(x)) for x in np.minimum(out_shape, scores.shape))
     scores_out = np.full(out_shape, fill_value=0, dtype=np.float32)
     scores_out[update] = data[0][update] - scores_norm[update]
-    scores_out[update] = np.divide(scores_out[update], 1 - scores_norm[update])
+    scores_out[update] += scores_norm[update].mean()
+
+    # scores_out[update] = np.divide(scores_out[update], 1 - scores_norm[update])
     scores_out = np.fmax(scores_out, 0, out=scores_out)
     data[0] = scores_out
 
@@ -478,15 +480,21 @@ def main():
     if orientations is None:
         translations, rotations, scores, details = [], [], [], []
 
-        # Data processed by normalize_input is guaranteed to have this shape
-        scores, offset, rotation_array, rotation_mapping, meta = data
+        var = None
+        # Data processed by normalize_input is guaranteed to have this shape)
+        scores, _, rotation_array, rotation_mapping, *_ = data
+        if len(data) == 6:
+            scores, _, rotation_array, rotation_mapping, var, *_ = data
 
         cropped_shape = np.subtract(
             scores.shape, np.multiply(args.min_boundary_distance, 2)
         ).astype(int)
 
         if args.min_boundary_distance > 0:
-            scores = centered_mask(scores, new_shape=cropped_shape)
+            _scores = np.zeros_like(scores)
+            subset = center_slice(scores.shape, cropped_shape)
+            _scores[subset] = scores[subset]
+            scores = _scores
 
         if args.n_false_positives is not None:
             # Rickgauer et al. 2017
@@ -499,17 +507,20 @@ def main():
             )
             args.n_false_positives = max(args.n_false_positives, 1)
             n_correlations = np.size(scores[cropped_slice]) * len(rotation_mapping)
+            std = np.std(scores[cropped_slice])
+            if var is not None:
+                std = np.asarray(np.sqrt(var)).reshape(())
+
             minimum_score = np.multiply(
                 erfcinv(2 * args.n_false_positives / n_correlations),
-                np.sqrt(2) * np.std(scores[cropped_slice]),
+                np.sqrt(2) * std,
             )
-            print(f"Determined minimum score cutoff: {minimum_score}.")
-            minimum_score = max(minimum_score, 0)
-            args.min_score = minimum_score
+            print(f"Determined cutoff --min-score {minimum_score}.")
+            args.min_score = max(minimum_score, 0)
 
         args.batch_dims = None
-        if hasattr(cli_args, "target_batch"):
-            args.batch_dims = cli_args.target_batch
+        if hasattr(cli_args, "batch_dims"):
+            args.batch_dims = cli_args.batch_dims
 
         peak_caller_kwargs = {
             "shape": scores.shape,
@@ -517,8 +528,8 @@ def main():
             "min_distance": args.min_distance,
             "min_boundary_distance": args.min_boundary_distance,
             "batch_dims": args.batch_dims,
-            "minimum_score": args.min_score,
-            "maximum_score": args.max_score,
+            "min_score": args.min_score,
+            "max_score": args.max_score,
         }
 
         peak_caller = PEAK_CALLERS[args.peak_caller](**peak_caller_kwargs)
@@ -611,6 +622,9 @@ def main():
             orientations.rotations[index] = angles
             orientations.scores[index] = score * -1
 
+    if args.angles_clockwise:
+        orientations.rotations *= -1
+
     if args.output_format in ("orientations", "relion4", "relion5"):
         file_format, extension = "text", "tsv"