pytme 0.2.3__cp311-cp311-macosx_14_0_arm64.whl → 0.2.5__cp311-cp311-macosx_14_0_arm64.whl

tme/preprocessor.py

@@ -16,8 +16,6 @@ from scipy.interpolate import interp1d, splrep, BSpline
 from scipy.optimize import differential_evolution, minimize
 
 from .types import NDArray
-from .backends import NumpyFFTWBackend
-from .matching_utils import euler_to_rotationmatrix
 
 
 class Preprocessor:
@@ -680,134 +678,14 @@ class Preprocessor:
             use_gaussian=gaussian_sigma == 0.0,
         )(shape=shape)["data"]
 
-    def wedge_mask(
-        self,
-        shape: Tuple[int],
-        tilt_angles: NDArray,
-        opening_axes: NDArray = 0,
-        sigma: float = 0,
-        omit_negative_frequencies: bool = True,
-    ) -> NDArray:
-        """
-        Create a wedge mask with the same shape as template by rotating a
-        plane according to tilt angles. The DC component of the filter is at the origin.
-
-        Parameters
-        ----------
-        shape : Tuple of ints
-            Shape of the output wedge array.
-        tilt_angles : NDArray
-            Tilt angles in format d dimensions N tilts [d x N].
-        opening_axes : NDArray
-            Axis running through the void defined by the wedge in format (N,)
-        sigma : float, optional
-            Standard deviation for Gaussian kernel used for smoothing the wedge.
-        omit_negative_frequencies : bool, optional
-            Whether the wedge mask should omit negative frequencies, i.e. be
-            applicable to symmetric Fourier transforms (see :obj:`numpy.fft.fftn`)
-
-        Returns
-        -------
-        NDArray
-            A numpy array containing the wedge mask.
-
-        Examples
-        --------
-        >>> import numpy as np
-        >>> from tme import Preprocessor
-        >>> angles = np.zeros((3, 10))
-        >>> angles[2, :] = np.linspace(-50, 55, 10)
-        >>> wedge = Preprocessor().wedge_mask(
-        >>>    shape = (50,50,50),
-        >>>    tilt_angles = angles,
-        >>>    omit_negative_frequencies = True
-        >>>    )
-        >>> wedge = np.fft.fftshift(wedge)
-
-        This will create a wedge that is open along axis 1, tilted
-        around axis 2 and propagated along axis 0. The code above would
-        be equivalent to the following
-
-        >>> wedge = Preprocessor().continuous_wedge_mask(
-        >>>    shape=(50,50,50),
-        >>>    start_tilt=50,
-        >>>    stop_tilt=55,
-        >>>    tilt_axis=1,
-        >>>    omit_negative_frequencies=False,
-        >>>    infinite_plane=False
-        >>>    )
-        >>> wedge = np.fft.fftshift(wedge)
-
-        with the difference being that :py:meth:`Preprocessor.continuous_wedge_mask`
-        does not consider individual plane tilts.
-
-        Raises
-        ------
-        ValueError
-            If opening_axes is neither a single value or defined for each tilt.
-
-        See Also
-        --------
-        :py:meth:`Preprocessor.step_wedge_mask`
-        :py:meth:`Preprocessor.continuous_wedge_mask`
-        """
-        opening_axes = np.asarray(opening_axes)
-        opening_axes = np.repeat(
-            opening_axes, tilt_angles.shape[1] // opening_axes.size
-        )
-
-        if opening_axes.size != tilt_angles.shape[1]:
-            raise ValueError(
-                "opening_axes has to be a single value or be defined for each tilt."
-            )
-
-        plane = np.zeros(shape, dtype=np.float32)
-        slices = tuple(slice(a, a + 1) for a in np.divide(shape, 2).astype(int))
-        plane_rotated, wedge_volume = np.zeros_like(plane), np.zeros_like(plane)
-        for index in range(tilt_angles.shape[1]):
-            plane.fill(0)
-            plane_rotated.fill(0)
-
-            opening_axis = opening_axes[index]
-            rotation_matrix = euler_to_rotationmatrix(
-                np.roll(tilt_angles[:, index], opening_axis - 1)
-            )
-
-            subset = tuple(
-                slice(None) if i != opening_axis else slices[opening_axis]
-                for i in range(plane.ndim)
-            )
-            plane[subset] = 1
-            NumpyFFTWBackend().rigid_transform(
-                arr=plane,
-                rotation_matrix=rotation_matrix,
-                out=plane_rotated,
-                use_geometric_center=True,
-                order=1,
-            )
-            wedge_volume += plane_rotated
-
-        wedge_volume = self.gaussian_filter(template=wedge_volume, sigma=sigma)
-        wedge_volume = np.where(wedge_volume > np.exp(-2), 1, 0)
-        wedge_volume = np.fft.ifftshift(wedge_volume)
-
-        if omit_negative_frequencies:
-            stop = 1 + (wedge_volume.shape[-1] // 2)
-            wedge_volume = wedge_volume[..., :stop]
-
-        return wedge_volume
-
     def step_wedge_mask(
         self,
-        start_tilt: float,
-        stop_tilt: float,
-        tilt_step: float,
         shape: Tuple[int],
         tilt_angles: Tuple[float] = None,
         opening_axis: int = 0,
         tilt_axis: int = 2,
-        sigma: float = 0,
-        weights: float = 1,
+        weights: float = None,
+        infinite_plane: bool = False,
         omit_negative_frequencies: bool = True,
     ) -> NDArray:
         """
@@ -816,14 +694,8 @@ class Preprocessor:
 
         Parameters
         ----------
-        start_tilt : float
-            Starting tilt angle in degrees, e.g. a stage tilt of 70 degrees
-            would yield a start_tilt value of 70.
-        stop_tilt : float
-            Ending tilt angle in degrees, , e.g. a stage tilt of -70 degrees
-            would yield a stop_tilt value of 70.
-        tilt_step : float
-            Angle between the different tilt planes.
+        tilt_angles : tuple of float
+            Sequence of tilt angles.
         shape : Tuple of ints
             Shape of the output wedge array.
         tilt_axis : int, optional
@@ -849,70 +721,21 @@ class Preprocessor:
         NDArray
             A numpy array containing the wedge mask.
 
-        Notes
-        -----
-        This function is equivalent to :py:meth:`Preprocessor.wedge_mask`, but much faster
-        for large shapes because it only considers a single tilt angle rather than the rotation
-        of an N-1 dimensional hyperplane in N dimensions.
-
         See Also
         --------
-        :py:meth:`Preprocessor.wedge_mask`
         :py:meth:`Preprocessor.continuous_wedge_mask`
         """
-        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)
-        subset = tuple(
-            slice(None) if i != 0 else slice(x // 2, x // 2 + 1)
-            for i, x in enumerate(plane.shape)
-        )
-        plane_rotated, wedge_volume = np.zeros_like(plane), np.zeros_like(plane)
-        for index in range(tilt_angles.shape[0]):
-            plane_rotated.fill(0)
-            plane[subset] = weights[index]
-            rotation_matrix = euler_to_rotationmatrix((tilt_angles[index], 0))
-            rotation_matrix = rotation_matrix[np.ix_((0, 1), (0, 1))]
-
-            NumpyFFTWBackend().rigid_transform(
-                arr=plane,
-                rotation_matrix=rotation_matrix,
-                out=plane_rotated,
-                use_geometric_center=True,
-                order=1,
-            )
-            wedge_volume += plane_rotated
-
-        # Ramp filtering would be more accurate
-        np.fmin(wedge_volume, np.max(weights), wedge_volume)
-
-        if sigma > 0:
-            wedge_volume = self.gaussian_filter(template=wedge_volume, sigma=sigma)
-
-        if opening_axis > tilt_axis:
-            wedge_volume = np.moveaxis(wedge_volume, 1, 0)
-
-        reshape_dimensions = tuple(
-            x if i in (opening_axis, tilt_axis) else 1 for i, x in enumerate(shape)
-        )
-
-        wedge_volume = wedge_volume.reshape(reshape_dimensions)
-        tile_dimensions = np.divide(shape, reshape_dimensions).astype(int)
-        wedge_volume = np.tile(wedge_volume, tile_dimensions)
-
-        wedge_volume = np.fft.ifftshift(wedge_volume)
-
-        if omit_negative_frequencies:
-            stop = 1 + (wedge_volume.shape[-1] // 2)
-            wedge_volume = wedge_volume[..., :stop]
-
-        return wedge_volume
+        from .preprocessing.tilt_series import WedgeReconstructed
+
+        return WedgeReconstructed(
+            angles=tilt_angles,
+            tilt_axis=tilt_axis,
+            opening_axis=opening_axis,
+            frequency_cutoff=None if infinite_plane else 0.5,
+            create_continuous_wedge=False,
+            weights=weights,
+            weight_wedge=weights is not None,
+        )(shape=shape, return_real_fourier=omit_negative_frequencies,)["data"]
 
     def continuous_wedge_mask(
         self,
@@ -921,8 +744,6 @@ class Preprocessor:
         shape: Tuple[int],
         opening_axis: int = 0,
         tilt_axis: int = 2,
-        sigma: float = 0,
-        extrude_plane: bool = True,
         infinite_plane: bool = True,
         omit_negative_frequencies: bool = True,
     ) -> NDArray:
@@ -950,13 +771,6 @@ class Preprocessor:
             - 2 for X-axis
         shape : Tuple of ints
             Shape of the output wedge array.
-        sigma : float, optional
-            Standard deviation for Gaussian kernel used for smoothing the wedge.
-        extrude_plane : bool, optional
-            Whether the tilted plane is extruded to 3D. By default, this represents
-            the effect of rotating a plane in 3D yielding a cylinder with wedge
-            insertion. If set to False, the returned mask has spherical shape,
-            analogous to rotating a line in 3D.
         omit_negative_frequencies : bool, optional
             Whether the wedge mask should omit negative frequencies, i.e. be
             applicable to symmetric Fourier transforms (see :obj:`numpy.fft.fftn`)
@@ -970,55 +784,19 @@ class Preprocessor:
             Array of the specified shape with the wedge created based on
             the tilt angles.
 
-        Examples
-        --------
-        >>> wedge = create_wedge(30, 60, 1, (64, 64, 64))
-
-        Notes
-        -----
-        The rotation plane is spanned by the tilt axis and the leftmost dimension
-        that is not the tilt axis.
-
         See Also
         --------
-        :py:meth:`Preprocessor.wedge_mask`
         :py:meth:`Preprocessor.step_wedge_mask`
         """
-        shape_center = np.divide(shape, 2).astype(int)
-
-        grid = (np.indices(shape).T - shape_center).T
-
-        start_radians = np.tan(np.radians(90 - start_tilt))
-        stop_radians = np.tan(np.radians(-1 * (90 - stop_tilt)))
-        max_tan_value = np.tan(np.radians(90)) + 1
-
-        with np.errstate(divide="ignore", invalid="ignore"):
-            ratios = np.where(
-                grid[opening_axis] == 0,
-                max_tan_value,
-                grid[tilt_axis] / grid[opening_axis],
-            )
-
-        wedge = np.logical_or(start_radians <= ratios, stop_radians >= ratios).astype(
-            np.float32
-        )
-
-        if extrude_plane:
-            distances = np.sqrt(grid[tilt_axis] ** 2 + grid[opening_axis] ** 2)
-        else:
-            distances = np.linalg.norm(grid, axis=0)
-
-        if not infinite_plane:
-            np.multiply(wedge, distances <= shape[tilt_axis] // 2, out=wedge)
-
-        wedge = self.gaussian_filter(template=wedge, sigma=sigma)
-        wedge = np.fft.ifftshift(wedge > np.exp(-2))
-
-        if omit_negative_frequencies:
-            stop = 1 + (wedge.shape[-1] // 2)
-            wedge = wedge[..., :stop]
-
-        return wedge
+        from .preprocessing.tilt_series import WedgeReconstructed
+
+        return WedgeReconstructed(
+            angles=(start_tilt, stop_tilt),
+            tilt_axis=tilt_axis,
+            opening_axis=opening_axis,
+            frequency_cutoff=None if infinite_plane else 0.5,
+            create_continuous_wedge=True,
+        )(shape=shape, return_real_fourier=omit_negative_frequencies)["data"]
 
 
 def window_kaiserb(width: int, beta: float = 3.2, order: int = 0) -> NDArray:

tme/structure.py

@@ -344,7 +344,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> structure
         Unique Chains: A-B, Atom Range: 1-1564 [N = 1564], Residue Range: 142-239 [N = 1564]
@@ -564,7 +564,7 @@ class Structure:
         >>> from importlib_resources import files
         >>> from tempfile import NamedTemporaryFile
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> oname = NamedTemporaryFile().name
         >>> structure = Structure.from_file(filename=fname)
         >>> structure.to_file(f"{oname}.cif") # Writes an mmCIF file to disk
@@ -760,7 +760,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> structure.subset_by_chain(chain="A")   # Keep A
         >>> structure.subset_by_chain(chain="A,B") # Keep A and B
@@ -804,7 +804,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> structure.subset_by_range(chain="A",start=150,stop=180)
         """
@@ -827,7 +827,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> structure.center_of_mass()
         array([-0.89391639, 29.94908928, -2.64736741])
@@ -863,7 +863,7 @@ class Structure:
         >>> from importlib_resources import files
         >>> from tme import Structure
         >>> from tme.matching_utils import get_rotation_matrices
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> structure.rigid_transform(
         >>>     rotation_matrix = get_rotation_matrices(60)[2],
@@ -902,7 +902,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> centered_structure, translation = structure.centered()
         >>> translation
@@ -1117,16 +1117,16 @@ class Structure:
         ----------
         positions : NDArray
             Array containing atomic positions in z,y,x format (n,d).
-        weights : [float]
+        weights : tuple of float
             The weights to use for the entries in positions.
-        resolution : float
+        resolution : float, optional
             The product of resolution and sigma_factor gives the sigma used to
             compute the discretized Gaussian.
-        sigma_factor : float
+        sigma_factor : float, optional
             The factor used with resolution to compute sigma. Default is 1 / (π√2).
-        cutoff_value : float
+        cutoff_value : float, optional
             The cutoff value for the Gaussian kernel. Default is 4.0.
-        sampling_rate : float
+        sampling_rate : float, optional
             Sampling rate along each dimension. One third of resolution by default.
 
         References
@@ -1160,8 +1160,8 @@ class Structure:
         positions = positions[:, ::-1]
         origin = positions.min(axis=0) - pad * sampling_rate
         positions = np.rint(np.divide((positions - origin), sampling_rate)).astype(int)
-        shape = positions.max(axis=0).astype(int) + pad + 1
 
+        shape = positions.max(axis=0).astype(int) + pad + 1
         out = np.zeros(shape, dtype=np.float32)
         np.add.at(out, tuple(positions.T), weights)
 
@@ -1225,17 +1225,17 @@ class Structure:
         origin : tuple of floats, optional
             Origin of the coordinate system in (z,y,x) form.
         chain : str, optional
-            Chain identified. Either single or comma separated string of chains.
+            Chains to be included. Either single or comma separated string of chains.
             Defaults to None which returns all chains.
         weight_type : str, optional
-            Weight given to individual atoms. Supported weight are:
+            Weight given to individual atoms. Supported weights are:
 
             +----------------------------+---------------------------------------+
-            | atomic_weight              | Using element unit point mass         |
+            | atomic_weight              | Using element weight point mass       |
             +----------------------------+---------------------------------------+
             | atomic_number              | Using atomic number point mass        |
             +----------------------------+---------------------------------------+
-            | gaussian                   | Represent atoms as isotropic Gaussian |
+            | gaussian                   | Using element weighted Gaussian mass  |
             +----------------------------+---------------------------------------+
             | van_der_waals_radius       | Using binary van der waal spheres     |
             +----------------------------+---------------------------------------+
@@ -1256,7 +1256,7 @@ class Structure:
         --------
         >>> from importlib_resources import files
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> vol, origin, sampling = structure.to_volume()
         >>> vol.shape, origin, sampling
@@ -1299,10 +1299,10 @@ class Structure:
             )
 
         temp = self.subset_by_chain(chain=chain)
-        positions, atoms, shape, sampling_rate, origin = temp._coordinate_to_position(
+        positions, atoms, _shape, sampling_rate, origin = temp._coordinate_to_position(
             shape=shape, sampling_rate=sampling_rate, origin=origin
         )
-        volume = np.zeros(shape, dtype=np.float32)
+        volume = np.zeros(_shape, dtype=np.float32)
         if weight_type in ("atomic_weight", "atomic_number"):
             weights = temp._get_atom_weights(atoms=atoms, weight_type=weight_type)
             np.add.at(volume, tuple(positions.T), weights)
@@ -1374,7 +1374,7 @@ class Structure:
         >>> from importlib_resources import files
         >>> from tme.matching_utils import get_rotation_matrices
         >>> from tme import Structure
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> transformed = structure.rigid_transform(
         >>>     rotation_matrix = get_rotation_matrices(60)[2],
@@ -1455,7 +1455,7 @@ class Structure:
         >>> from importlib_resources import files
         >>> from tme import Structure
         >>> from tme.matching_utils import get_rotation_matrices
-        >>> fname = str(files("tme.tests.data").joinpath("Structures/5khe.cif"))
+        >>> fname = str(files("tests.data").joinpath("Structures/5khe.cif"))
         >>> structure = Structure.from_file(filename=fname)
         >>> transformed = structure.rigid_transform(
         >>>     rotation_matrix = get_rotation_matrices(60)[2],

pytme-0.2.3.dist-info/RECORD

@@ -1,75 +0,0 @@
-pytme-0.2.3.data/scripts/estimate_ram_usage.py,sha256=R1NDpFajcF-MonJ4a43SfDlA-nxBYwK7D2quzCdsVFM,2767
-pytme-0.2.3.data/scripts/match_template.py,sha256=JJbZjxSdggKBHhEy-5lRwI6RslNzLAmZ9RPqwAnhkys,39750
-pytme-0.2.3.data/scripts/postprocess.py,sha256=50PwDfOWe2Fdws4J5K-k2SgM55fARlAWCnIsv-l0i-4,24414
-pytme-0.2.3.data/scripts/preprocess.py,sha256=fJMVyHJwiXorr8P2L47bVWSkduJYS3H5r-zrQpp4jjA,3782
-pytme-0.2.3.data/scripts/preprocessor_gui.py,sha256=mlxh-5GNaN7quEbd_Wso0R4gJ7DOJioL3rio2CCXuqw,39239
-scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scripts/estimate_ram_usage.py,sha256=rN7haobnHg3YcgGJIp81FNiCzy8-saJGeEurQlmQmNQ,2768
-scripts/eval.py,sha256=ebJVLxbRlB6TI5YHNr0VavZ4lmaRdf8QVafyiDhh_oU,2528
-scripts/extract_candidates.py,sha256=DAfNyuauogWvSdRWIbtH44tsk9buLn13JrL1zJjJGLE,8373
-scripts/match_template.py,sha256=p4iS2_bp3ZdSgf0jB1t0SOojgCj-0KfwgRXHnLmfAHE,39751
-scripts/match_template_filters.py,sha256=Gj4a1b_S5NWp_dfFEPFn0D7jGf-qYgBbnTvZZ4bwqOQ,42036
-scripts/postprocess.py,sha256=FdA4AZgsbz8enYT6q46akWX4O5Hdxrun4PUdomYhrPA,24415
-scripts/preprocess.py,sha256=kZQd8SyMyLpHJzj59qSxtjFg2GMdhRuc5OQqoqj8Nh8,3783
-scripts/preprocessor_gui.py,sha256=_UaZyUViI8Xj-IDw18xjnyolB3ROMTFoLS-3Wqm7Uh0,39240
-scripts/refine_matches.py,sha256=Y17Ku_t0W9vglPNF2oU5EFrqoedJIm3lCGl-hXRHvjc,21920
-tme/__init__.py,sha256=liARhKZ565F2Y02iWRbFzfrTCkL5You3YaUSiqUkees,202
-tme/__version__.py,sha256=PNiDER4qM19h9zdsdfgKt2_dT4WgYK7EguJ8RU2qA_g,22
-tme/analyzer.py,sha256=kYxtzBCp02OJrlMME8Njh-9wIZAvsuhTHNAveNplssY,50466
-tme/density.py,sha256=BRM2jCDLvKDWDyzKhfc_APB4k398m9G5SnwFD1lRq8I,84204
-tme/extensions.cpython-311-darwin.so,sha256=KM0UcTYdq0Gib8rC6yVt7KnXrVvPNcWS-cvuYW2aPso,392496
-tme/matching_data.py,sha256=nEKG3DMwHwLjcO08sQUp6FiIkOLwtXS_36Y557nOvJQ,25319
-tme/matching_exhaustive.py,sha256=D5r53AyGNnGGsRgiNRo3L7YCrMeVCAgjlEurzDbLCv4,19483
-tme/matching_memory.py,sha256=bmCAUYyXWEet-1XXhldtc0irio2ytMSsAzWYyFI5LNM,11273
-tme/matching_optimization.py,sha256=Y8HfecXiOvAHXM1viBaQ_aXljqqTnGwlOlFe0MJpDRQ,45082
-tme/matching_scores.py,sha256=CECxl2Lh0TMLfZYnoCJXy3euGf8i9J0eHsAD7sqvWGU,30962
-tme/matching_utils.py,sha256=nh4D090eIrTO2d_Tjyr7FnLrTx3hRXie9mt5zJUFsZ4,39998
-tme/memory.py,sha256=6xeIMAncQkgYDi6w-PIYgFEWRTUPu0_OTCeRO0p9r9Q,11029
-tme/orientations.py,sha256=KsYXJuLRLYXRHsDjP9_Tn1jXxIVPSaYkw1wRrWH3nUQ,26027
-tme/parser.py,sha256=fNiCAdsWI4ql92F1Ob4suiVzpjUOBlh2lad1iNY_FP8,13772
-tme/preprocessor.py,sha256=ZhlP-8b4NzAzRogWOnk5DLNh_tqCMOpc4msQIJEKBTU,48566
-tme/structure.py,sha256=k5kgFNHkM2mUvXS7VAwaevltLC1mUxEiDhMW0TqTNjo,65834
-tme/types.py,sha256=NAY7C4qxE6yz-DXVtClMvFfoOV-spWGLNfpLATZ1LcU,442
-tme/backends/__init__.py,sha256=4S68W2WJNZ9t33QSrRs6aL3OIyEVFo_zVsqXjS1iWYA,5185
-tme/backends/_jax_utils.py,sha256=YuNJHCYnSqOESMV-9LPr-ZxBg6Zvax2euBjsZM-j-64,5906
-tme/backends/cupy_backend.py,sha256=1nnCJ4nT7tJsXu1mrJGCy7x0Yg1wWVRg4SdzsQ2qiiw,9284
-tme/backends/jax_backend.py,sha256=qRUQ6-j1gSUCeYDgla2qAO3ptnuCUar8uXC68B2lQ7Y,10344
-tme/backends/matching_backend.py,sha256=KfCOKD_rA9el3Y7BeH17KJ1apCUIIhhvn-vmbkb3CB0,33750
-tme/backends/mlx_backend.py,sha256=FJhqmCzgjXAjWGX1HhHFrCy_We4YwQQBkKFNG05ctzM,7788
-tme/backends/npfftw_backend.py,sha256=JDTc_1QcVi9jU3yLQF7jkgwQz_Po60OhkKuV2V3g5v8,16997
-tme/backends/pytorch_backend.py,sha256=61cAu8HBtGPDL8vSJx49f6yBxkLoWiX0X49Dy2tHAuk,15038
-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=hC8Qfh_a_fk4o7v82c4-TZYYRFfo5XttcghvpkzBo0A,6193
-tme/preprocessing/composable_filter.py,sha256=dOE1WDzF3xc-Chv63PWSiW3Gq4wXyAbvNvKuy-lERL8,780
-tme/preprocessing/compose.py,sha256=tilp14UhBh98SJVJhC_STbgi7i8HeU4FB7B7KUOD8gc,1458
-tme/preprocessing/frequency_filters.py,sha256=x900ntX0QI46lDdycPISO-7K0XgM0015ksCOFlm-yM4,12964
-tme/preprocessing/tilt_series.py,sha256=PFzWuXUn-uTqj2gwt_y5IV2Cte1IcL-Ule26LYORe9M,33844
-pytme-0.2.3.dist-info/LICENSE,sha256=K1IUNSVAz8BXbpH5EA8y5FpaHdvFXnAF2zeK95Lr2bY,18467
-pytme-0.2.3.dist-info/METADATA,sha256=C6HajoocJkveHyDTm01adKSZjEIgI6AbYQEMTXuAhfE,5278
-pytme-0.2.3.dist-info/WHEEL,sha256=IHsX_ZtCj0uMf8jtN3eK3zfXfu1SfKRsLbDhsprnhR0,109
-pytme-0.2.3.dist-info/entry_points.txt,sha256=ff3LQL3FCWfCYOwFiP9zatm7laUbnwCkuPELkQVyUO4,241
-pytme-0.2.3.dist-info/top_level.txt,sha256=J8FUkazOb2fZ0n_KexnqCGyNOtie2bwisFSUBiM5-0w,12
-pytme-0.2.3.dist-info/RECORD,,