pytme 0.2.0__cp311-cp311-macosx_14_0_arm64.whl → 0.2.1__cp311-cp311-macosx_14_0_arm64.whl

{pytme-0.2.0.data → pytme-0.2.1.data}/scripts/match_template.py

@@ -217,7 +217,7 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
             if args.tilt_weighting not in ("angle", None):
                 raise ValueError(
                     "Tilt weighting schemes other than 'angle' or 'None' require "
-                    "a specification of electron doses."
+                    "a specification of electron doses via --tilt_angles."
                 )
 
             wedge = Wedge(
@@ -240,31 +240,58 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
         wedge.sampling_rate = template.sampling_rate
         template_filter.append(wedge)
         if not isinstance(wedge, WedgeReconstructed):
-            template_filter.append(ReconstructFromTilt(
-                reconstruction_filter = args.reconstruction_filter
-            ))
+            template_filter.append(
+                ReconstructFromTilt(
+                    reconstruction_filter=args.reconstruction_filter,
+                    interpolation_order=args.reconstruction_interpolation_order,
+                )
+            )
 
-    if args.ctf_file is not None:
+    if args.ctf_file is not None or args.defocus is not None:
         from tme.preprocessing.tilt_series import CTF
 
-        ctf = CTF.from_file(args.ctf_file)
-        n_tilts_ctfs, n_tils_angles = len(ctf.defocus_x), len(wedge.angles)
-        if n_tilts_ctfs != n_tils_angles:
-            raise ValueError(
-                f"CTF file contains {n_tilts_ctfs} micrographs, but match_template "
-                f"recieved {n_tils_angles} tilt angles. Expected one angle "
-                "per micrograph."
+        needs_reconstruction = True
+        if args.ctf_file is not None:
+            ctf = CTF.from_file(args.ctf_file)
+            n_tilts_ctfs, n_tils_angles = len(ctf.defocus_x), len(wedge.angles)
+            if n_tilts_ctfs != n_tils_angles:
+                raise ValueError(
+                    f"CTF file contains {n_tilts_ctfs} micrographs, but match_template "
+                    f"recieved {n_tils_angles} tilt angles. Expected one angle "
+                    "per micrograph."
+                )
+            ctf.angles = wedge.angles
+            ctf.opening_axis, ctf.tilt_axis = args.wedge_axes
+        else:
+            needs_reconstruction = False
+            ctf = CTF(
+                defocus_x=[args.defocus],
+                phase_shift=[args.phase_shift],
+                defocus_y=None,
+                angles=[0],
+                shape=None,
+                return_real_fourier=True,
             )
-        ctf.angles = wedge.angles
-        ctf.opening_axis, ctf.tilt_axis = args.wedge_axes
-
-        if isinstance(template_filter[-1], ReconstructFromTilt):
+        ctf.sampling_rate = template.sampling_rate
+        ctf.flip_phase = not args.no_flip_phase
+        ctf.amplitude_contrast = args.amplitude_contrast
+        ctf.spherical_aberration = args.spherical_aberration
+        ctf.acceleration_voltage = args.acceleration_voltage * 1e3
+        ctf.correct_defocus_gradient = args.correct_defocus_gradient
+
+        if not needs_reconstruction:
+            template_filter.append(ctf)
+        elif isinstance(template_filter[-1], ReconstructFromTilt):
             template_filter.insert(-1, ctf)
         else:
             template_filter.insert(0, ctf)
-            template_filter.insert(1, ReconstructFromTilt(
-                reconstruction_filter = args.reconstruction_filter
-            ))
+            template_filter.insert(
+                1,
+                ReconstructFromTilt(
+                    reconstruction_filter=args.reconstruction_filter,
+                    interpolation_order=args.reconstruction_interpolation_order,
+                ),
+            )
 
     if args.lowpass or args.highpass is not None:
         lowpass, highpass = args.lowpass, args.highpass
@@ -293,6 +320,14 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
         template_filter.append(whitening_filter)
         target_filter.append(whitening_filter)
 
+    needs_reconstruction = any(
+        [isinstance(t, ReconstructFromTilt) for t in template_filter]
+    )
+    if needs_reconstruction and args.reconstruction_filter is None:
+        warnings.warn(
+            "Consider using a --reconstruction_filter such as 'ramp' to avoid artifacts."
+        )
+
     template_filter = Compose(template_filter) if len(template_filter) else None
     target_filter = Compose(target_filter) if len(target_filter) else None
 
@@ -510,7 +545,7 @@ def parse_args():
         dest="no_pass_smooth",
         action="store_false",
         default=True,
-        help="Whether a hard edge filter should be used for --lowpass and --highpass."
+        help="Whether a hard edge filter should be used for --lowpass and --highpass.",
     )
     filter_group.add_argument(
         "--pass_format",
@@ -519,7 +554,7 @@ def parse_args():
         required=False,
         choices=["sampling_rate", "voxel", "frequency"],
         help="How values passed to --lowpass and --highpass should be interpreted. "
-        "By default, they are assumed to be in units of sampling rate, e.g. Ångstrom."
+        "By default, they are assumed to be in units of sampling rate, e.g. Ångstrom.",
     )
     filter_group.add_argument(
         "--whiten_spectrum",
@@ -561,23 +596,90 @@ def parse_args():
         "grigorieff (exposure filter as defined in Grant and Grigorieff 2015)."
         "relion and grigorieff require electron doses in --tilt_angles weights column.",
     )
-    # filter_group.add_argument(
-    #     "--ctf_file",
-    #     dest="ctf_file",
-    #     type=str,
-    #     required=False,
-    #     default=None,
-    #     help="Path to a file with CTF parameters from CTFFIND4.",
-    # )
     filter_group.add_argument(
         "--reconstruction_filter",
         dest="reconstruction_filter",
         type=str,
         required=False,
-        choices = ["ram-lak", "ramp", "shepp-logan", "cosine", "hamming"],
+        choices=["ram-lak", "ramp", "ramp-cont", "shepp-logan", "cosine", "hamming"],
         default=None,
         help="Filter applied when reconstructing (N+1)-D from N-D filters.",
     )
+    filter_group.add_argument(
+        "--reconstruction_interpolation_order",
+        dest="reconstruction_interpolation_order",
+        type=int,
+        default=1,
+        required=False,
+        help="Analogous to --interpolation_order but for reconstruction.",
+    )
+
+    ctf_group = parser.add_argument_group("Contrast Transfer Function")
+    ctf_group.add_argument(
+        "--ctf_file",
+        dest="ctf_file",
+        type=str,
+        required=False,
+        default=None,
+        help="Path to a file with CTF parameters from CTFFIND4. Each line will be "
+        "interpreted as tilt obtained at the angle specified in --tilt_angles. ",
+    )
+    ctf_group.add_argument(
+        "--defocus",
+        dest="defocus",
+        type=float,
+        required=False,
+        default=None,
+        help="Defocus in units of sampling rate (typically Ångstrom). "
+        "Superseded by --ctf_file.",
+    )
+    ctf_group.add_argument(
+        "--phase_shift",
+        dest="phase_shift",
+        type=float,
+        required=False,
+        default=0,
+        help="Phase shift in degrees. Superseded by --ctf_file.",
+    )
+    ctf_group.add_argument(
+        "--acceleration_voltage",
+        dest="acceleration_voltage",
+        type=float,
+        required=False,
+        default=300,
+        help="Acceleration voltage in kV, defaults to 300.",
+    )
+    ctf_group.add_argument(
+        "--spherical_aberration",
+        dest="spherical_aberration",
+        type=float,
+        required=False,
+        default=2.7e7,
+        help="Spherical aberration in units of sampling rate (typically Ångstrom).",
+    )
+    ctf_group.add_argument(
+        "--amplitude_contrast",
+        dest="amplitude_contrast",
+        type=float,
+        required=False,
+        default=0.07,
+        help="Amplitude contrast, defaults to 0.07.",
+    )
+    ctf_group.add_argument(
+        "--no_flip_phase",
+        dest="no_flip_phase",
+        action="store_false",
+        required=False,
+        help="Whether the phase of the computed CTF should not be flipped.",
+    )
+    ctf_group.add_argument(
+        "--correct_defocus_gradient",
+        dest="correct_defocus_gradient",
+        action="store_true",
+        required=False,
+        help="[Experimental] Whether to compute a more accurate 3D CTF incorporating "
+        "defocus gradients.",
+    )
 
     performance_group = parser.add_argument_group("Performance")
     performance_group.add_argument(
@@ -655,12 +757,11 @@ def parse_args():
     )
 
     args = parser.parse_args()
+    args.version = __version__
 
     if args.interpolation_order < 0:
         args.interpolation_order = None
 
-    args.ctf_file = None
-
     if args.temp_directory is None:
         default = abspath(".")
         if os.environ.get("TMPDIR", None) is not None:
@@ -725,12 +826,13 @@ def main():
             sampling_rate=target.sampling_rate,
         )
 
-    if not np.allclose(target.sampling_rate, template.sampling_rate):
-        print(
-            f"Resampling template to {target.sampling_rate}. "
-            "Consider providing a template with the same sampling rate as the target."
-        )
-        template = template.resample(target.sampling_rate, order=3)
+    if target.sampling_rate.size == template.sampling_rate.size:
+        if not np.allclose(target.sampling_rate, template.sampling_rate):
+            print(
+                f"Resampling template to {target.sampling_rate}. "
+                "Consider providing a template with the same sampling rate as the target."
+            )
+            template = template.resample(target.sampling_rate, order=3)
 
     template_mask = load_and_validate_mask(
         mask_target=template, mask_path=args.template_mask
@@ -863,31 +965,46 @@ def main():
     if args.memory is None:
         args.memory = int(args.memory_scaling * available_memory)
 
-    target_padding = np.zeros_like(template.shape)
-    if args.pad_target_edges:
-        target_padding = template.shape
+    callback_class = MaxScoreOverRotations
+    if args.peak_calling:
+        callback_class = PeakCallerMaximumFilter
+
+    matching_data = MatchingData(
+        target=target,
+        template=template.data,
+        target_mask=target_mask,
+        template_mask=template_mask,
+        invert_target=args.invert_target_contrast,
+        rotations=parse_rotation_logic(args=args, ndim=template.data.ndim),
+    )
+
+    template_filter, target_filter = setup_filter(args, template, target)
+    matching_data.template_filter = template_filter
+    matching_data.target_filter = target_filter
 
-    template_box = template.shape
+    template_box = matching_data._output_template_shape
     if not args.pad_fourier:
         template_box = np.ones(len(template_box), dtype=int)
 
-    callback_class = MaxScoreOverRotations
-    if args.peak_calling:
-        callback_class = PeakCallerMaximumFilter
+    target_padding = np.zeros(
+        (backend.size(matching_data._output_template_shape)), dtype=int
+    )
+    if args.pad_target_edges:
+        target_padding = matching_data._output_template_shape
 
     splits, schedule = compute_parallelization_schedule(
         shape1=target.shape,
-        shape2=template_box,
-        shape1_padding=target_padding,
+        shape2=tuple(int(x) for x in template_box),
+        shape1_padding=tuple(int(x) for x in target_padding),
         max_cores=args.cores,
         max_ram=args.memory,
         split_only_outer=args.use_gpu,
         matching_method=args.score,
         analyzer_method=callback_class.__name__,
         backend=backend._backend_name,
-        float_nbytes=backend.datatype_bytes(backend._default_dtype),
+        float_nbytes=backend.datatype_bytes(backend._float_dtype),
         complex_nbytes=backend.datatype_bytes(backend._complex_dtype),
-        integer_nbytes=backend.datatype_bytes(backend._default_dtype_int),
+        integer_nbytes=backend.datatype_bytes(backend._int_dtype),
     )
 
     if splits is None:
@@ -898,20 +1015,6 @@ def main():
         exit(-1)
 
     matching_setup, matching_score = MATCHING_EXHAUSTIVE_REGISTER[args.score]
-    matching_data = MatchingData(target=target, template=template.data)
-    matching_data.rotations = parse_rotation_logic(args=args, ndim=target.data.ndim)
-
-    template_filter, target_filter = setup_filter(args, template, target)
-    matching_data.template_filter = template_filter
-    matching_data.target_filter = target_filter
-
-    matching_data.template_filter = template_filter
-    matching_data._invert_target = args.invert_target_contrast
-    if target_mask is not None:
-        matching_data.target_mask = target_mask
-    if template_mask is not None:
-        matching_data.template_mask = template_mask.data
-
     n_splits = np.prod(list(splits.values()))
     target_split = ", ".join(
         [":".join([str(x) for x in axis]) for axis in splits.items()]
@@ -945,13 +1048,23 @@ def main():
         "Lowpass": args.lowpass,
         "Highpass": args.highpass,
         "Smooth Pass": args.no_pass_smooth,
-        "Pass Format" : args.pass_format,
+        "Pass Format": args.pass_format,
         "Spectral Whitening": args.whiten_spectrum,
         "Wedge Axes": args.wedge_axes,
         "Tilt Angles": args.tilt_angles,
         "Tilt Weighting": args.tilt_weighting,
-        "CTF": args.ctf_file,
+        "Reconstruction Filter": args.reconstruction_filter,
     }
+    if args.ctf_file is not None or args.defocus is not None:
+        filter_args["CTF File"] = args.ctf_file
+        filter_args["Defocus"] = args.defocus
+        filter_args["Phase Shift"] = args.phase_shift
+        filter_args["No Flip Phase"] = args.no_flip_phase
+        filter_args["Acceleration Voltage"] = args.acceleration_voltage
+        filter_args["Spherical Aberration"] = args.spherical_aberration
+        filter_args["Amplitude Contrast"] = args.amplitude_contrast
+        filter_args["Correct Defocus"] = args.correct_defocus_gradient
+
     filter_args = {k: v for k, v in filter_args.items() if v is not None}
     if len(filter_args):
         print_block(
@@ -1000,15 +1113,16 @@ def main():
             candidates[0] *= target_mask.data
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", category=UserWarning)
+            nbytes = backend.datatype_bytes(backend._float_dtype)
+            dtype = np.float32 if nbytes == 4 else np.float16
+            rot_dim = matching_data.rotations.shape[1]
             candidates[3] = {
                 x: euler_from_rotationmatrix(
-                    np.frombuffer(i, dtype=matching_data.rotations.dtype).reshape(
-                        candidates[0].ndim, candidates[0].ndim
-                    )
+                    np.frombuffer(i, dtype=dtype).reshape(rot_dim, rot_dim)
                 )
                 for i, x in candidates[3].items()
             }
-    candidates.append((target.origin, template.origin, target.sampling_rate, args))
+    candidates.append((target.origin, template.origin, template.sampling_rate, args))
     write_pickle(data=candidates, filename=args.output)
 
     runtime = time() - start

{pytme-0.2.0.data → pytme-0.2.1.data}/scripts/postprocess.py

@@ -9,7 +9,7 @@ import argparse
 from sys import exit
 from os import getcwd
 from os.path import join, abspath
-from typing import List
+from typing import List, Tuple
 from os.path import splitext
 
 import numpy as np
@@ -29,6 +29,7 @@ from tme.matching_utils import (
     euler_to_rotationmatrix,
     euler_from_rotationmatrix,
 )
+from tme.matching_optimization import create_score_object, optimize_match
 
 PEAK_CALLERS = {
     "PeakCallerSort": PeakCallerSort,
@@ -181,6 +182,13 @@ def parse_args():
         required=False,
         help="Number of accepted false-positives picks to determine minimum score.",
     )
+    additional_group.add_argument(
+        "--local_optimization",
+        action="store_true",
+        required=False,
+        help="[Experimental] Perform local optimization of candidates. Useful when the "
+        "number of identified candidats is small (< 10).",
+    )
 
     args = parser.parse_args()
 
@@ -195,28 +203,34 @@ def parse_args():
 
     if args.minimum_score is not None or args.n_false_positives is not None:
         args.number_of_peaks = np.iinfo(np.int64).max
-    else:
+    elif args.number_of_peaks is None:
         args.number_of_peaks = 1000
 
     return args
 
 
-def load_template(filepath: str, sampling_rate: NDArray, center: bool = True):
+def load_template(
+    filepath: str,
+    sampling_rate: NDArray,
+    centering: bool = True,
+    target_shape: Tuple[int] = None,
+):
     try:
         template = Density.from_file(filepath)
-        center_of_mass = template.center_of_mass(template.data)
+        center = np.divide(np.subtract(template.shape, 1), 2)
         template_is_density = True
-    except ValueError:
+    except Exception:
         template = Structure.from_file(filepath)
-        center_of_mass = template.center_of_mass()[::-1]
+        center = template.center_of_mass()[::-1]
         template = Density.from_structure(template, sampling_rate=sampling_rate)
         template_is_density = False
 
-    translation = np.zeros_like(center_of_mass)
-    if center:
+    translation = np.zeros_like(center)
+    if centering and template_is_density:
         template, translation = template.centered(0)
+        center = np.divide(np.subtract(template.shape, 1), 2)
 
-    return template, center_of_mass, translation, template_is_density
+    return template, center, translation, template_is_density
 
 
 def merge_outputs(data, filepaths: List[str], args):
@@ -226,7 +240,7 @@ def merge_outputs(data, filepaths: List[str], args):
     if data[0].ndim != data[2].ndim:
         return data, 1
 
-    from tme.matching_exhaustive import _normalize_under_mask
+    from tme.matching_exhaustive import normalize_under_mask
 
     def _norm_scores(data, args):
         target_origin, _, sampling_rate, cli_args = data[-1]
@@ -235,7 +249,7 @@ def merge_outputs(data, filepaths: List[str], args):
         ret = load_template(
             filepath=cli_args.template,
             sampling_rate=sampling_rate,
-            center=not cli_args.no_centering,
+            centering=not cli_args.no_centering,
         )
         template, center_of_mass, translation, template_is_density = ret
 
@@ -256,7 +270,7 @@ def merge_outputs(data, filepaths: List[str], args):
             mask.shape, np.multiply(args.min_boundary_distance, 2)
         ).astype(int)
         mask[cropped_shape] = 0
-        _normalize_under_mask(template=data[0], mask=mask, mask_intensity=mask.sum())
+        normalize_under_mask(template=data[0], mask=mask, mask_intensity=mask.sum())
         return data[0]
 
     entities = np.zeros_like(data[0])
@@ -280,7 +294,7 @@ def main():
     ret = load_template(
         filepath=cli_args.template,
         sampling_rate=sampling_rate,
-        center=not cli_args.no_centering,
+        centering=not cli_args.no_centering,
     )
     template, center_of_mass, translation, template_is_density = ret
 
@@ -310,7 +324,9 @@ def main():
         max_shape = np.max(template.shape)
         args.min_boundary_distance = np.ceil(np.divide(max_shape, 2))
 
-    # data, entities = merge_outputs(data=data, filepaths=args.input_file[1:], args=args)
+    entities = None
+    if len(args.input_file) > 1:
+        data, entities = merge_outputs(data=data, filepaths=args.input_file, args=args)
 
     orientations = args.orientations
     if orientations is None:
@@ -346,31 +362,33 @@ def main():
                 minimum_score = max(minimum_score, 0)
                 args.minimum_score = minimum_score
 
-            peak_caller = PEAK_CALLERS[args.peak_caller](
-                number_of_peaks=args.number_of_peaks,
-                min_distance=args.min_distance,
-                min_boundary_distance=args.min_boundary_distance,
-            )
-            if args.minimum_score is not None:
-                args.number_of_peaks = np.inf
+            args.batch_dims = None
+            if hasattr(cli_args, "target_batch"):
+                args.batch_dims = cli_args.target_batch
+
+            peak_caller_kwargs = {
+                "number_of_peaks": args.number_of_peaks,
+                "min_distance": args.min_distance,
+                "min_boundary_distance": args.min_boundary_distance,
+                "batch_dims": args.batch_dims,
+            }
 
+            peak_caller = PEAK_CALLERS[args.peak_caller](**peak_caller_kwargs)
             peak_caller(
                 scores,
-                rotation_matrix=np.eye(3),
+                rotation_matrix=np.eye(template.data.ndim),
                 mask=template.data,
                 rotation_mapping=rotation_mapping,
                 rotation_array=rotation_array,
                 minimum_score=args.minimum_score,
             )
             candidates = peak_caller.merge(
-                candidates=[tuple(peak_caller)],
-                number_of_peaks=args.number_of_peaks,
-                min_distance=args.min_distance,
-                min_boundary_distance=args.min_boundary_distance,
+                candidates=[tuple(peak_caller)], **peak_caller_kwargs
             )
             if len(candidates) == 0:
-                print("Found no peaks. Consider changing peak calling parameters.")
-                exit(-1)
+                candidates = [[], [], [], []]
+                print("Found no peaks, consider changing peak calling parameters.")
+                exit(0)
 
             for translation, _, score, detail in zip(*candidates):
                 rotations.append(rotation_mapping[rotation_array[tuple(translation)]])
@@ -381,8 +399,13 @@ def main():
             for i in range(translation.shape[0]):
                 rotations.append(euler_from_rotationmatrix(rotation[i]))
 
-        rotations = np.vstack(rotations).astype(float)
+        if len(rotations):
+            rotations = np.vstack(rotations).astype(float)
         translations, scores, details = candidates[0], candidates[2], candidates[3]
+
+        if entities is not None:
+            details = entities[tuple(translations.T)]
+
         orientations = Orientations(
             translations=translations,
             rotations=rotations,
@@ -390,14 +413,55 @@ def main():
             details=details,
         )
 
-    if args.minimum_score is not None:
+    if args.minimum_score is not None and len(orientations.scores):
         keep = orientations.scores >= args.minimum_score
         orientations = orientations[keep]
 
-    if args.maximum_score is not None:
+    if args.maximum_score is not None and len(orientations.scores):
         keep = orientations.scores <= args.maximum_score
         orientations = orientations[keep]
 
+    if args.peak_oversampling > 1:
+        peak_caller = peak_caller = PEAK_CALLERS[args.peak_caller]()
+        if data[0].ndim != data[2].ndim:
+            print(
+                "Input pickle does not contain template matching scores."
+                " Cannot oversample peaks."
+            )
+            exit(-1)
+        orientations.translations = peak_caller.oversample_peaks(
+            score_space=data[0],
+            peak_positions=orientations.translations,
+            oversampling_factor=args.peak_oversampling,
+        )
+
+    if args.local_optimization:
+        target = Density.from_file(cli_args.target)
+        orientations.translations = orientations.translations.astype(np.float32)
+        orientations.rotations = orientations.rotations.astype(np.float32)
+        for index, (translation, angles, *_) in enumerate(orientations):
+            score_object = create_score_object(
+                score="FLC",
+                target=target.data.copy(),
+                template=template.data.copy(),
+                template_mask=template_mask.data.copy(),
+            )
+
+            center = np.divide(template.shape, 2)
+            init_translation = np.subtract(translation, center)
+            bounds_translation = tuple((x - 5, x + 5) for x in init_translation)
+
+            translation, rotation_matrix, score = optimize_match(
+                score_object=score_object,
+                optimization_method="basinhopping",
+                bounds_translation=bounds_translation,
+                maxiter=3,
+                x0=[*init_translation, *angles],
+            )
+            orientations.translations[index] = np.add(translation, center)
+            orientations.rotations[index] = angles
+            orientations.scores[index] = score * -1
+
     if args.output_format == "orientations":
         orientations.to_file(filename=f"{args.output_prefix}.tsv", file_format="text")
         exit(0)
@@ -515,7 +579,6 @@ def main():
             )
             rotation_matrix = rotation.inv().as_matrix()
 
-            # rotation_matrix = euler_to_rotationmatrix(orientations.rotations[index])
             subset = Density(target.data[obs_slices[index]])
             subset = subset.rigid_transform(rotation_matrix=rotation_matrix, order=1)
 
@@ -526,35 +589,30 @@ def main():
         ret.to_file(f"{args.output_prefix}_average.mrc")
         exit(0)
 
-    if args.peak_oversampling > 1:
-        peak_caller = peak_caller = PEAK_CALLERS[args.peak_caller]()
-        if data[0].ndim != data[2].ndim:
-            print(
-                "Input pickle does not contain template matching scores."
-                " Cannot oversample peaks."
-            )
-            exit(-1)
-        orientations.translations = peak_caller.oversample_peaks(
-            score_space=data[0],
-            translations=orientations.translations,
-            oversampling_factor=args.oversampling_factor,
-        )
+    template, center, *_ = load_template(
+        filepath=cli_args.template,
+        sampling_rate=sampling_rate,
+        centering=not cli_args.no_centering,
+        target_shape=target.shape,
+    )
 
     for index, (translation, angles, *_) in enumerate(orientations):
         rotation_matrix = euler_to_rotationmatrix(angles)
         if template_is_density:
-            translation = np.subtract(translation, center_of_mass)
+            translation = np.subtract(translation, center)
             transformed_template = template.rigid_transform(
                 rotation_matrix=rotation_matrix
             )
-            new_origin = np.add(target_origin / sampling_rate, translation)
-            transformed_template.origin = np.multiply(new_origin, sampling_rate)
+            transformed_template.origin = np.add(
+                target_origin, np.multiply(translation, sampling_rate)
+            )
+
         else:
             template = Structure.from_file(cli_args.template)
             new_center_of_mass = np.add(
                 np.multiply(translation, sampling_rate), target_origin
             )
-            translation = np.subtract(new_center_of_mass, center_of_mass)
+            translation = np.subtract(new_center_of_mass, center)
             transformed_template = template.rigid_transform(
                 translation=translation[::-1],
                 rotation_matrix=rotation_matrix[::-1, ::-1],

{pytme-0.2.0.data → pytme-0.2.1.data}/scripts/preprocessor_gui.py

@@ -789,7 +789,10 @@ class AlignmentWidget(widgets.Container):
         active_layer = self.viewer.layers.selection.active
         if active_layer is None:
             return ()
-        return [i for i in range(active_layer.data.ndim)]
+        try:
+            return [i for i in range(active_layer.data.ndim)]
+        except Exception:
+            return ()
 
     def _update_align_axis(self, *args):
         self.align_axis.choices = self._get_active_layer_dims()