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

tme/preprocessing/tilt_series.py

@@ -20,11 +20,14 @@ from ._utils import (
     compute_tilt_shape,
     crop_real_fourier,
     centered_grid,
-    fftfreqn
+    fftfreqn,
+    shift_fourier,
 )
 
 
-def create_reconstruction_filter(filter_shape : Tuple[int], filter_type : str):
+def create_reconstruction_filter(
+    filter_shape: Tuple[int], filter_type: str, **kwargs: Dict
+):
     """Create a reconstruction filter of given filter_type.
 
     Parameters
@@ -32,20 +35,25 @@ def create_reconstruction_filter(filter_shape : Tuple[int], filter_type : str):
     filter_shape : tuple of int
         Shape of the returned filter
     filter_type: str
-        The type of created filter, available options include:
+        The type of created filter, available options are:
 
         +---------------+----------------------------------------------------+
-        | 'ram-lak'     | Returns |w|                                        |
+        | ram-lak       | Returns |w|                                        |
         +---------------+----------------------------------------------------+
-        | 'ramp'        | Principles of Computerized Tomographic Imaging Avin|
+        | ramp-cont     | Principles of Computerized Tomographic Imaging Avin|
         |               | ash C. Kak and Malcolm Slaney Chap 3 Eq. 61 [1]_   |
         +---------------+----------------------------------------------------+
-        | 'shepp-logan' | |w| * sinc(|w| / 2) [2]_                           |
+        | ramp          | Like ramp-cont but considering tilt angles         |
         +---------------+----------------------------------------------------+
-        | 'cosine'      | |w| * cos(|w| * pi / 2) [2]_                       |
+        | shepp-logan   | |w| * sinc(|w| / 2) [2]_                           |
         +---------------+----------------------------------------------------+
-        | 'hamming'     | |w| * (.54 + .46 ( cos(|w| * pi))) [2]_            |
+        | cosine        | |w| * cos(|w| * pi / 2) [2]_                       |
         +---------------+----------------------------------------------------+
+        | hamming       | |w| * (.54 + .46 ( cos(|w| * pi))) [2]_            |
+        +---------------+----------------------------------------------------+
+
+    kwargs: Dict
+        Keyword arguments for particular filter_types.
 
     Returns
     -------
@@ -58,11 +66,11 @@ def create_reconstruction_filter(filter_shape : Tuple[int], filter_type : str):
     .. [2]  https://odlgroup.github.io/odl/index.html
     """
     filter_type = str(filter_type).lower()
-    freq = fftfreqn(filter_shape, sampling_rate = .5, compute_euclidean_norm = True)
+    freq = fftfreqn(filter_shape, sampling_rate=0.5, compute_euclidean_norm=True)
 
-    if filter_type == 'ram-lak':
+    if filter_type == "ram-lak":
         ret = np.copy(freq)
-    elif filter_type == "ramp":
+    elif filter_type == "ramp-cont":
         ret, ndim = None, len(filter_shape)
         for dim, size in enumerate(filter_shape):
             n = np.concatenate(
@@ -81,20 +89,38 @@ def create_reconstruction_filter(filter_shape : Tuple[int], filter_type : str):
             else:
                 ret = ret * ret1d
         ret = 2 * np.real(np.fft.fftn(ret))
-    elif filter_type == 'shepp-logan':
+    elif filter_type == "ramp":
+        tilt_angles = kwargs.get("tilt_angles", False)
+        if tilt_angles is False:
+            raise ValueError("'ramp' filter requires specifying tilt angles.")
+        size, odd = filter_shape[0], filter_shape[0] % 2
+        ret = np.arange(-size // 2 + odd, size // 2 + odd, 1, dtype=np.float32)
+        ret /= size // 2
+        ret *= 0.5
+        np.abs(ret, out=ret)
+
+        min_increment = np.radians(np.min(np.abs(np.diff(np.sort(tilt_angles)))))
+        ret *= min_increment * size
+        np.fmin(ret, 1, out=ret)
+
+        ret = np.tile(ret[:, np.newaxis], (1, filter_shape[1]))
+
+    elif filter_type == "shepp-logan":
         ret = freq * np.sinc(freq / 2)
-    elif filter_type == 'cosine':
+    elif filter_type == "cosine":
         ret = freq * np.cos(freq * np.pi / 2)
-    elif filter_type == 'hamming':
+    elif filter_type == "hamming":
         ret = freq * (0.54 + 0.46 * np.cos(freq * np.pi))
     else:
         raise ValueError("Unsupported filter type")
 
     return ret
 
+
 @dataclass
 class ReconstructFromTilt:
     """Reconstruct a volume from a tilt series."""
+
     #: Shape of the reconstruction.
     shape: Tuple[int] = None
     #: Angle of each individual tilt.
@@ -111,7 +137,7 @@ class ReconstructFromTilt:
     reconstruction_filter: str = None
 
     def __call__(self, **kwargs):
-        func_args = vars(self)
+        func_args = vars(self).copy()
         func_args.update(kwargs)
 
         ret = self.reconstruct(**func_args)
@@ -135,11 +161,11 @@ class ReconstructFromTilt:
         tilt_axis: int,
         interpolation_order: int = 1,
         return_real_fourier: bool = True,
-        reconstruction_filter:str = None,
+        reconstruction_filter: str = None,
         **kwargs,
     ):
         """
-        Reconstruct the volume from tilt series.
+        Reconstruct a volume from a tilt series.
 
         Parameters:
         -----------
@@ -156,7 +182,7 @@ class ReconstructFromTilt:
         interpolation_order : int, optional
             Interpolation order used for rotation, defautls to 1.
         return_real_fourier : bool, optional
-           Whether to return a share compliant with rfftn, defaults to True.
+           Whether to return a shape compliant with rfftn, defaults to True.
         reconstruction_filter : bool, optional
            Filter window applied during reconstruction.
            See :py:meth:`create_reconstruction_filter` for available options.
@@ -170,11 +196,13 @@ class ReconstructFromTilt:
             return data
 
         data = backend.to_backend_array(data)
-        volume_temp = backend.zeros(shape, dtype=backend._default_dtype)
-        volume_temp_rotated = backend.zeros(shape, dtype=backend._default_dtype)
-        volume = backend.zeros(shape, dtype=backend._default_dtype)
+        volume_temp = backend.zeros(shape, dtype=backend._float_dtype)
+        volume_temp_rotated = backend.zeros(shape, dtype=backend._float_dtype)
+        volume = backend.zeros(shape, dtype=backend._float_dtype)
 
-        slices = tuple(slice(a, a + 1) for a in backend.divide(shape, 2).astype(int))
+        slices = tuple(
+            slice(a, a + 1) for a in backend.astype(backend.divide(shape, 2), int)
+        )
         subset = tuple(
             slice(None) if i != opening_axis else slices[opening_axis]
             for i in range(len(shape))
@@ -187,9 +215,19 @@ class ReconstructFromTilt:
         rec_filter = 1
         if reconstruction_filter is not None:
             rec_filter = create_reconstruction_filter(
-                filter_type = reconstruction_filter,
-                filter_shape = tuple(x for x in wedges[0].shape if x != 1)
+                filter_type=reconstruction_filter,
+                filter_shape=tuple(x for x in wedges[0].shape if x != 1),
+                tilt_angles=angles,
             )
+            if tilt_axis > 0:
+                rec_filter = rec_filter.T
+
+            # This is most likely an upstream bug
+            if tilt_axis == 1 and opening_axis == 0:
+                rec_filter = rec_filter.T
+
+            rec_filter = backend.to_backend_array(rec_filter)
+            rec_filter = backend.reshape(rec_filter, wedges[0].shape)
 
         for index in range(len(angles)):
             backend.fill(angles_loop, 0)
@@ -199,7 +237,7 @@ class ReconstructFromTilt:
             volume_temp[subset] = wedges[index] * rec_filter
 
             angles_loop[tilt_axis] = angles[index]
-            angles_loop = backend.roll(angles_loop, opening_axis - 1, axis=0)
+            angles_loop = backend.roll(angles_loop, (opening_axis - 1,), axis=0)
             rotation_matrix = euler_to_rotationmatrix(
                 backend.to_numpy_array(angles_loop)
             )
@@ -214,11 +252,7 @@ class ReconstructFromTilt:
             )
             backend.add(volume, volume_temp_rotated, out=volume)
 
-        shift = backend.add(
-            backend.astype(backend.divide(volume.shape, 2), int),
-            backend.mod(volume.shape, 2),
-        )
-        volume = backend.roll(volume, shift, tuple(i for i in range(len(shift))))
+        volume = shift_fourier(data=volume, shape_is_real_fourier=False)
 
         if return_real_fourier:
             volume = crop_real_fourier(volume)
@@ -333,7 +367,7 @@ class Wedge:
         return ret
 
     def __call__(self, **kwargs: Dict) -> NDArray:
-        func_args = vars(self)
+        func_args = vars(self).copy()
         func_args.update(kwargs)
 
         weight_types = {
@@ -353,10 +387,7 @@ class Wedge:
             func_args["weights"] = np.cos(np.radians(self.angles))
 
         ret = weight_types[weight_type](**func_args)
-        ret = backend.astype(
-            backend.to_backend_array(ret),
-            backend._default_dtype
-        )
+        ret = backend.astype(backend.to_backend_array(ret), backend._float_dtype)
 
         return {
             "data": ret,
@@ -374,7 +405,6 @@ class Wedge:
         angles: Tuple[float],
         opening_axis: int,
         tilt_axis: int,
-        frequency_cutoff: float = 0.5,
         **kwargs,
     ) -> NDArray:
         """
@@ -386,14 +416,6 @@ class Wedge:
         wedge, wedges = np.ones(tilt_shape), np.zeros((len(angles), *tilt_shape))
         for index, angle in enumerate(angles):
             wedge.fill(weights[index])
-            frequency_grid = frequency_grid_at_angle(
-                shape=shape,
-                opening_axis=opening_axis,
-                tilt_axis=tilt_axis,
-                angle=angle,
-                sampling_rate=1,
-            )
-            np.multiply(wedge, frequency_grid <= frequency_cutoff, out=wedge)
             wedges[index] = wedge
 
         return wedges
@@ -422,7 +444,7 @@ class Wedge:
                 angle=angle,
                 sampling_rate=1,
             )
-            frequency_mask = frequency_grid <= self.frequency_cutoff
+            # frequency_mask = frequency_grid <= self.frequency_cutoff
 
             sigma = np.sqrt(self.weights[index] * 4 / (8 * np.pi**2))
             sigma = -2 * np.pi**2 * sigma**2
@@ -430,7 +452,7 @@ class Wedge:
             np.multiply(sigma, frequency_grid, out=frequency_grid)
             np.exp(frequency_grid, out=frequency_grid)
             np.multiply(frequency_grid, np.cos(np.radians(angle)), out=frequency_grid)
-            np.multiply(frequency_grid, frequency_mask, out=frequency_grid)
+            # np.multiply(frequency_grid, frequency_mask, out=frequency_grid)
 
             wedges[index] = frequency_grid
 
@@ -456,10 +478,12 @@ class Wedge:
         .. [1]  Timothy GrantNikolaus Grigorieff (2015), eLife 4:e06980.
         """
         tilt_shape = compute_tilt_shape(
-            shape=self.shape, opening_axis=self.opening_axis, reduce_dim=True,
+            shape=self.shape,
+            opening_axis=self.opening_axis,
+            reduce_dim=True,
         )
 
-        wedges = np.zeros((len(self.angles), *tilt_shape), dtype=backend._default_dtype)
+        wedges = np.zeros((len(self.angles), *tilt_shape), dtype=backend._float_dtype)
         for index, angle in enumerate(self.angles):
             frequency_grid = frequency_grid_at_angle(
                 shape=self.shape,
@@ -468,13 +492,13 @@ class Wedge:
                 angle=angle,
                 sampling_rate=1,
             )
-            frequency_mask = frequency_grid <= self.frequency_cutoff
+            # frequency_mask = frequency_grid <= self.frequency_cutoff
 
             with np.errstate(divide="ignore"):
-                np.power(frequency_grid, power, out = frequency_grid)
-                np.multiply(amplitude, frequency_grid, out = frequency_grid)
-                np.add(frequency_grid, offset, out = frequency_grid)
-                np.multiply(-2, frequency_grid, out = frequency_grid)
+                np.power(frequency_grid, power, out=frequency_grid)
+                np.multiply(amplitude, frequency_grid, out=frequency_grid)
+                np.add(frequency_grid, offset, out=frequency_grid)
+                np.multiply(-2, frequency_grid, out=frequency_grid)
                 np.divide(
                     self.weights[index],
                     frequency_grid,
@@ -482,7 +506,7 @@ class Wedge:
                 )
 
             np.exp(frequency_grid, out=frequency_grid)
-            np.multiply(frequency_grid, frequency_mask, out=frequency_grid)
+            # np.multiply(frequency_grid, frequency_mask, out=frequency_grid)
 
             wedges[index] = frequency_grid
 
@@ -512,8 +536,8 @@ class WedgeReconstructed:
         stop_tilt: float = None,
         opening_axis: int = 0,
         tilt_axis: int = 2,
-        weight_wedge : bool = False,
-        create_continuous_wedge : bool = False,
+        weight_wedge: bool = False,
+        create_continuous_wedge: bool = False,
         **kwargs: Dict,
     ):
         self.angles = angles
@@ -538,7 +562,7 @@ class WedgeReconstructed:
         Dict
             A dictionary containing the reconstructed wedge and related information.
         """
-        func_args = vars(self)
+        func_args = vars(self).copy()
         func_args.update(kwargs)
 
         if kwargs.get("is_fourier_shape", False):
@@ -549,10 +573,7 @@ class WedgeReconstructed:
             func = self.continuous_wedge
 
         ret = func(shape=shape, **func_args)
-        ret = backend.astype(
-            backend.to_backend_array(ret),
-            backend._default_dtype
-        )
+        ret = backend.astype(backend.to_backend_array(ret), backend._float_dtype)
 
         return {
             "data": ret,
@@ -561,7 +582,7 @@ class WedgeReconstructed:
             "tilt_axis": func_args["tilt_axis"],
             "opening_axis": func_args["opening_axis"],
             "is_multiplicative_filter": True,
-            "angles" : func_args["angles"],
+            "angles": func_args["angles"],
         }
 
     @staticmethod
@@ -678,7 +699,7 @@ class CTF:
     #: The defocus value in x direction.
     defocus_x: float
     #: The tilt angles.
-    angles: Tuple[float]
+    angles: Tuple[float] = None
     #: The axis around which the wedge is opened, defaults to None.
     opening_axis: int = None
     #: The axis along which the tilt is applied, defaults to None.
@@ -689,8 +710,8 @@ class CTF:
     sampling_rate: Tuple[float] = 1
     #: The acceleration voltage in Volts, defaults to 300e3.
     acceleration_voltage: float = 300e3
-    #: The spherical aberration coefficient, defaults to 2.7e3.
-    spherical_aberration: float = 2.7e3
+    #: The spherical aberration coefficient, defaults to 2.7e7.
+    spherical_aberration: float = 2.7e7
     #: The amplitude contrast, defaults to 0.07.
     amplitude_contrast: float = 0.07
     #: The phase shift, defaults to 0.
@@ -699,6 +720,10 @@ class CTF:
     defocus_angle: float = 0
     #: The defocus value in y direction, defaults to None.
     defocus_y: float = None
+    #: Whether the returned CTF should be phase-flipped.
+    flip_phase: bool = True
+    #: Whether to return a format compliant with rfft. Only relevant for single angles.
+    return_real_fourier: bool = False
 
     @classmethod
     def from_file(cls, filename: str) -> "CTF":
@@ -811,7 +836,6 @@ class CTF:
             "defocus_x",
             "defocus_y",
         ]
-
         if "sampling_rate" in kwargs:
             self.sampling_rate = kwargs["sampling_rate"]
 
@@ -819,19 +843,22 @@ class CTF:
             kwargs["electron_wavelength"] = self._compute_electron_wavelength()
 
         for key, value in kwargs.items():
-            if key in voxel_based:
-                value = value / self.sampling_rate
+            if key in voxel_based and value is not None:
+                value = np.divide(value, np.max(self.sampling_rate))
             setattr(self, key, value)
 
     def __call__(self, **kwargs) -> NDArray:
-        func_args = vars(self)
+        func_args = vars(self).copy()
         func_args.update(kwargs)
 
+        if len(func_args["angles"]) != len(func_args["defocus_x"]):
+            func_args["angles"] = self.angles
+            func_args["return_real_fourier"] = False
+            func_args["tilt_axis"] = None
+            func_args["opening_axis"] = None
+
         ret = self.weight(**func_args)
-        ret = backend.astype(
-            backend.to_backend_array(ret),
-            backend._default_dtype
-        )
+        ret = backend.astype(backend.to_backend_array(ret), backend._float_dtype)
         return {
             "data": ret,
             "angles": func_args["angles"],
@@ -856,6 +883,8 @@ class CTF:
         sampling_rate: Tuple[float] = 1,
         acceleration_voltage: float = 300e3,
         spherical_aberration: float = 2.7e3,
+        flip_phase: bool = True,
+        return_real_fourier: bool = False,
         **kwargs: Dict,
     ) -> NDArray:
         """
@@ -891,6 +920,8 @@ class CTF:
             The acceleration voltage in electron microscopy, defaults to 300e3.
         spherical_aberration : float, optional
             The spherical aberration coefficient, defaults to 2.7e3.
+        flip_phase : bool, optional
+            Whether the returned CTF should be phase-flipped.
         **kwargs : Dict
             Additional keyword arguments.
 
@@ -899,21 +930,31 @@ class CTF:
         NDArray
             A stack containing the CTF weight.
         """
+        defoci_x = np.atleast_1d(defocus_x)
+        defoci_y = np.atleast_1d(defocus_y)
+        phase_shift = np.atleast_1d(phase_shift)
+        angles = np.atleast_1d(angles)
+        defocus_angle = np.atleast_1d(defocus_angle)
+
+        sampling_rate = np.max(sampling_rate)
         tilt_shape = compute_tilt_shape(
             shape=shape, opening_axis=opening_axis, reduce_dim=True
         )
         stack = np.zeros((len(angles), *tilt_shape))
-        electron_wavelength = self._compute_electron_wavelength()
-        defoci_x = defocus_x
-        defoci_y = defocus_y
+        electron_wavelength = self._compute_electron_wavelength() / sampling_rate
+
+        correct_defocus_gradient &= len(shape) == 3
+        correct_defocus_gradient &= tilt_axis is not None
+        correct_defocus_gradient &= opening_axis is not None
+
         for index, angle in enumerate(angles):
-            grid = centered_grid(shape=tilt_shape)
-            grid = np.divide(grid.T, (sampling_rate, sampling_rate)).T
+            grid = backend.to_numpy_array(centered_grid(shape=tilt_shape))
+            grid = np.divide(grid.T, sampling_rate).T
 
             defocus_x, defocus_y = defoci_x[index], defoci_y[index]
 
             # This should be done after defocus_x computation
-            if correct_defocus_gradient and len(shape) == 3:
+            if correct_defocus_gradient:
                 angle_rad = np.radians(angle)
 
                 defocus_gradient = np.multiply(grid[1], np.sin(angle_rad))
@@ -923,13 +964,9 @@ class CTF:
                 )[0]
 
                 if tilt_axis > remaining_axis:
-                    defocus_x = np.add(
-                        defocus_x, np.multiply(defocus_gradient, np.sin(angle_rad))
-                    )
+                    defocus_x = np.add(defocus_x, defocus_gradient)
                 elif tilt_axis < remaining_axis and defocus_y is not None:
-                    defocus_y = np.add(
-                        defocus_y, np.multiply(defocus_gradient.T, np.sin(angle_rad))
-                    )
+                    defocus_y = np.add(defocus_y, defocus_gradient.T)
 
             if defocus_y is not None:
                 defocus_sum = np.add(defocus_x, defocus_y)
@@ -946,10 +983,10 @@ class CTF:
                 angle=angle,
                 sampling_rate=1,
             )
-
+            frequency_grid *= frequency_grid <= 0.5
             np.square(frequency_grid, out=frequency_grid)
-            electron_aberration = spherical_aberration * electron_wavelength**2
 
+            electron_aberration = spherical_aberration * electron_wavelength**2
             chi = defocus_x - 0.5 * electron_aberration * frequency_grid
             np.multiply(chi, np.pi * electron_wavelength, out=chi)
             np.multiply(chi, frequency_grid, out=chi)
@@ -964,4 +1001,17 @@ class CTF:
             np.sin(-chi, out=chi)
             stack[index] = chi
 
+        if flip_phase:
+            np.abs(stack, out=stack)
+
+        np.negative(stack, out=stack)
+        stack = np.squeeze(stack)
+
+        stack = backend.to_backend_array(stack)
+
+        if len(angles) == 1:
+            stack = shift_fourier(data=stack, shape_is_real_fourier=False)
+            if return_real_fourier:
+                stack = crop_real_fourier(stack)
+
         return stack

tme/preprocessor.py

@@ -1191,6 +1191,9 @@ class Preprocessor:
         if tilt_angles is None:
             tilt_angles = np.arange(-start_tilt, stop_tilt + tilt_step, tilt_step)
 
+        shape = tuple(int(x) for x in shape)
+        opening_axis, tilt_axis = int(opening_axis), int(tilt_axis)
+
         weights = np.asarray(weights)
         weights = np.repeat(weights, tilt_angles.size // weights.size)
         plane = np.zeros((shape[opening_axis], shape[tilt_axis]), dtype=np.float32)

tme/structure.py

@@ -480,7 +480,6 @@ class Structure:
         filename : str
             The filename of the file to write.
         """
-        data_out = []
         if np.any(np.vectorize(len)(self.chain_identifier) > 2):
             warnings.warn("Chain identifiers longer than one will be shortened.")
 
@@ -612,6 +611,9 @@ class Structure:
 
         ret = ""
         for category, subdict in output_data.items():
+            if not len(subdict):
+                continue
+
             ret += "#\n"
             is_loop = isinstance(subdict[list(subdict.keys())[0]], list)
             if not is_loop:
@@ -776,6 +778,7 @@ class Structure:
 
         origin : Tuple[float,]
             The origin of the coordinate system.
+
         Returns
         -------
         Tuple[NDArray, List[str], Tuple[int, ], float, Tuple[float,]]

pytme-0.2.0.dist-info/RECORD

@@ -1,72 +0,0 @@
-pytme-0.2.0.data/scripts/estimate_ram_usage.py,sha256=R1NDpFajcF-MonJ4a43SfDlA-nxBYwK7D2quzCdsVFM,2767
-pytme-0.2.0.data/scripts/match_template.py,sha256=7MFgUS0W1WKG95FvLLYEJVc-zHt3BKP-R_4pgnY3ijk,35496
-pytme-0.2.0.data/scripts/postprocess.py,sha256=mgSkDoW9NNQiYYq8jkJxHRlHUkOkpkwCzxeqwQTZPps,21011
-pytme-0.2.0.data/scripts/preprocess.py,sha256=zog-l2Je-GeouJ6SnamOMuHgTn7fFPiGnO5X03y5qSY,2527
-pytme-0.2.0.data/scripts/preprocessor_gui.py,sha256=dX8y9FjCqwYIgZZ4G3xaFqIGB6FqY0ohiY9VodMBXBI,35189
-scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scripts/estimate_ram_usage.py,sha256=rN7haobnHg3YcgGJIp81FNiCzy8-saJGeEurQlmQmNQ,2768
-scripts/extract_candidates.py,sha256=L2IXg99hgW8jUBp06e6PEDO-Y5iUhoFuhe0i5B9gcOE,6871
-scripts/match_template.py,sha256=s3rbo_qEiN7uMaKLybzI_PLUvUztws8VWysHbEGJFi8,35497
-scripts/match_template_filters.py,sha256=u0eqbayRr-rTfag5rVGEMciZ3u6FVMmuwHB847WwRMc,35428
-scripts/postprocess.py,sha256=rqsBmbJWX_yG6fUDcwXMjlHorqgetgYcmgzm4yEsj9U,21012
-scripts/preprocess.py,sha256=ebJVLxbRlB6TI5YHNr0VavZ4lmaRdf8QVafyiDhh_oU,2528
-scripts/preprocessor_gui.py,sha256=3K2PXCboUC2v9u6JyyNzPkAWn_TyMeWhFfshESUNvTk,35190
-scripts/refine_matches.py,sha256=zV7piR5tGhrbomYN1tjnFDOfPInU07APU8syciSUZz8,7077
-tme/__init__.py,sha256=MGVeRX1f5k6RwExBcffZtCM7igNNtpoIr2G2yJZ4OHI,251
-tme/__version__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
-tme/analyzer.py,sha256=-bVqdVdUD2gypS2vLu7NObgaY39KFhyN9rEA0-mSOZQ,55480
-tme/density.py,sha256=mKZ8hnOsVzo87jKqoJ8jfE9lLrGvySUCKMLvpk7GGu4,88091
-tme/extensions.cpython-311-darwin.so,sha256=jUKGwYCpx9B6DAz3EDL5vPbfoxwQVM2KwQBizMDWkaA,412480
-tme/helpers.py,sha256=TMtBuJoZk6q4M_rfkr8yPpGzJD74ycqyN3yXMuU9mr4,23625
-tme/matching_constrained.py,sha256=NAJnZpusjQs5rKabHiNyrclXSPm27K0V8HVFjTQ2zB0,6725
-tme/matching_data.py,sha256=zR3-iUeE9DJlGSvk71GT2ZI_XpYj1plw2igOvUrgOLo,24218
-tme/matching_exhaustive.py,sha256=wvjjc5CcmVg-XOaV6Chcc6CGP0YjfEARPizpinEQ6Hw,58993
-tme/matching_memory.py,sha256=bmCAUYyXWEet-1XXhldtc0irio2ytMSsAzWYyFI5LNM,11273
-tme/matching_optimization.py,sha256=-Ptd-QxvamHLbsnxY_hBiQModFvYVnnfEkUIEcGmc_Y,41894
-tme/matching_utils.py,sha256=qLcRcfMCURsA5vFvJDUBa7xIAHsICWn_PB_jOYK3Pb0,42520
-tme/orientations.py,sha256=sEGhwBIE19jeRsMr5OZ1VM5ccRBpN5uThx6xG9obbo0,19118
-tme/parser.py,sha256=tA9ABeV95cZn8lJCukVUaocQ9RguR6ZZzQsMXf_-ud0,13887
-tme/preprocessor.py,sha256=Yu-YUp5H4Vkdr9mGGEfZse7WzMtR3Sq5t2VY5Xb5Xzw,51111
-tme/structure.py,sha256=1Dlh6gFn1VhoIr7H9ZDgOfaPJbVVfKv_c8AA00X_lbQ,52465
-tme/types.py,sha256=2Tyh_xnMLxIWYb3aJDAUb6GWpaL6gcYMUm2YNbJlAPI,295
-tme/backends/__init__.py,sha256=xB2GBUFRskppvEs6S74VH0Pi-nXnIvu9_QFhESlcl3Y,4366
-tme/backends/cupy_backend.py,sha256=4x8vy3eIpHKmfjg5BtqB9J0-gP0fWcT85FY-rFRXgVU,13145
-tme/backends/matching_backend.py,sha256=E3cMXnMEazYJUr9RP5Q5rMEAf3vbkiOwzWrx5amt_nI,29311
-tme/backends/mlx_backend.py,sha256=MrwICZpUiAcpZXON70r4SH-KsWxfhq1PdHUe80WbT-k,8467
-tme/backends/npfftw_backend.py,sha256=BHARQV9lo4OWCaKKo4Q4FkDvYpT12g5fgtQsTo0eTa4,27408
-tme/backends/pytorch_backend.py,sha256=0QrWX_MSE8ymhaniAzRBgMVL4h5QBJrbLbMbnnaWveE,18293
-tme/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tme/data/c48n309.npy,sha256=NwH64mOEbm3tStq5c98o81fY1vMOoq4nvXDAh7Z7iZg,296768
-tme/data/c48n527.npy,sha256=saSUMTa1R0MisPvgFL02a7IHQSwEZ-mJu0v3qJjg5AU,506048
-tme/data/c48n9.npy,sha256=bDVLV6mWjZHSQfeDc-MOCKKarfc1jaNeVvpoe2xMUy4,8768
-tme/data/c48u1.npy,sha256=JeXMFzFITs2ezdc3x5lp3jo1cHHHHVADSA1Tpf77kXs,1088
-tme/data/c48u1153.npy,sha256=ECiEximtYDWtIux3Fwe_EJlyn08gUqP85DN9gjkT9_k,1107008
-tme/data/c48u1201.npy,sha256=aceC_Jeienz_81X4520nPpZcg5tnRhbW795EqbpWkrg,1153088
-tme/data/c48u1641.npy,sha256=p4LwW3LzdTjrUUpA7H53RfNWxYfPX0XjeSwZ39Ac78Q,1575488
-tme/data/c48u181.npy,sha256=mLYXrv1YHLH6DsBp5MkxHkxlxgMnj1mw_KKI0udH-FY,173888
-tme/data/c48u2219.npy,sha256=p8TQeX8YHu4pdxnwJjEAlQWAPa66W7kpK96iZKZr9JE,2130368
-tme/data/c48u27.npy,sha256=k03ZNEsoPwBKCy8IeIa5G0WRZqjGZMtX6Ibu7EpJHvU,26048
-tme/data/c48u2947.npy,sha256=icI97ED6ct66y7FIaJAugmjzrIWk7CINCxtO3wDTnrU,2829248
-tme/data/c48u3733.npy,sha256=tla-__Pf-hpN6h04vtFIfkkFdCLple11VO06kr1dXkM,3583808
-tme/data/c48u4749.npy,sha256=tItOA4oV7SiqCCREwz3fyEpZoxM0lCq_jfEo5_-fp2s,4559168
-tme/data/c48u5879.npy,sha256=bFk89MllIFCX_sLXTYWFquSyN1NuahH4wwnEsPJLxzA,5643968
-tme/data/c48u7111.npy,sha256=CMy9kI2edH-q9eTIVdgUtXurplYNI7Uqp4dXfkkVdf8,6826688
-tme/data/c48u815.npy,sha256=bCuJxLtm0Sjg3GGxtyjGzRYZ1G0Gz79XHI-71GvqQnI,782528
-tme/data/c48u83.npy,sha256=7ODJYnsiuDjGbgd9GFopsyIW2IjrYI0J2X2f-cK868U,79808
-tme/data/c48u8649.npy,sha256=-IPlpR4zrPQZWhhSPu4zEulFdrCEVgTMFffCB5d-huE,8303168
-tme/data/c600v.npy,sha256=JqSu3ALoL1A9iguehc0YGUMFPsh2fprHHp76VXeFXIw,2528
-tme/data/c600vc.npy,sha256=Yht-GFXDSjjGvsjFBvyxxEZAI-ODADPd5gEgFNZQVTA,14528
-tme/data/metadata.yaml,sha256=fAgX-mEzB0QMHTEtYDG4cSMbJhYxBbDJH3sdvJvL7a8,750
-tme/data/quat_to_numpy.py,sha256=-gkDZb10fKBxwfYrSLCUWvMB76TzZWELCeKsYProwws,1333
-tme/preprocessing/__init__.py,sha256=7O3vDzJcIfxovJkf7avWSPtzaIVlTbmsW7egQFukC_s,98
-tme/preprocessing/_utils.py,sha256=KW8nAQqd7zDMI8IsIwLmGv5vwYuKWulCc0pYfpXmz-c,4833
-tme/preprocessing/composable_filter.py,sha256=k85XCxtGaCSMzbbF3KTzWJoMpcEAi4b_4uTNRVnPym0,779
-tme/preprocessing/compose.py,sha256=e6RW1Lz1MDq8b1uo0Z1WlPlUE3rWSj9YzlV35ZCwmXg,1321
-tme/preprocessing/frequency_filters.py,sha256=q4duOq6jvHMB-0wmyJQbQU41jXAiS-nW0MEMCBMnMyU,10634
-tme/preprocessing/tilt_series.py,sha256=_d4ajaJPgcqUT6tlaqvNCHtUqV-P0hebzzSOwKv0tsQ,32661
-pytme-0.2.0.dist-info/LICENSE,sha256=K1IUNSVAz8BXbpH5EA8y5FpaHdvFXnAF2zeK95Lr2bY,18467
-pytme-0.2.0.dist-info/METADATA,sha256=Wu3iU5wzfD6dVhMJg4ucdkUGBL_XbYaEcwQxI4Tkbrs,2165
-pytme-0.2.0.dist-info/WHEEL,sha256=BDgKu9_KNfDn85ptly0T56JpX4avXH07X_ZCqAJnQwY,110
-pytme-0.2.0.dist-info/entry_points.txt,sha256=ff3LQL3FCWfCYOwFiP9zatm7laUbnwCkuPELkQVyUO4,241
-pytme-0.2.0.dist-info/top_level.txt,sha256=J8FUkazOb2fZ0n_KexnqCGyNOtie2bwisFSUBiM5-0w,12
-pytme-0.2.0.dist-info/RECORD,,