pytme 0.2.2__cp311-cp311-macosx_14_0_arm64.whl → 0.2.4__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
@@ -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
@@ -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.2.dist-info/RECORD

@@ -1,74 +0,0 @@
-pytme-0.2.2.data/scripts/estimate_ram_usage.py,sha256=R1NDpFajcF-MonJ4a43SfDlA-nxBYwK7D2quzCdsVFM,2767
-pytme-0.2.2.data/scripts/match_template.py,sha256=FXAzPUnKMM2_thOtTZUKtIDV7GCmhFmLXm2yJDCI6G0,41456
-pytme-0.2.2.data/scripts/postprocess.py,sha256=K3tP8licTsCW1LKy8hQ8rMA7UrJ0AakM3kffx_1d4n4,24780
-pytme-0.2.2.data/scripts/preprocess.py,sha256=zog-l2Je-GeouJ6SnamOMuHgTn7fFPiGnO5X03y5qSY,2527
-pytme-0.2.2.data/scripts/preprocessor_gui.py,sha256=3eGC5RqnnZ3aXyfKEVstddLvKQP46kvyclj4-q01vAA,39275
-scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scripts/estimate_ram_usage.py,sha256=rN7haobnHg3YcgGJIp81FNiCzy8-saJGeEurQlmQmNQ,2768
-scripts/extract_candidates.py,sha256=DAfNyuauogWvSdRWIbtH44tsk9buLn13JrL1zJjJGLE,8373
-scripts/match_template.py,sha256=tEHfYXvfoBZB7bFjaBrHG3qH_e-U96fRfruB4n1uH9U,41457
-scripts/match_template_filters.py,sha256=Gj4a1b_S5NWp_dfFEPFn0D7jGf-qYgBbnTvZZ4bwqOQ,42036
-scripts/postprocess.py,sha256=TngTI7R8VaotxyOR9o5Hgmppjn_ILJ6ek1uwyHjkuco,24781
-scripts/preprocess.py,sha256=ebJVLxbRlB6TI5YHNr0VavZ4lmaRdf8QVafyiDhh_oU,2528
-scripts/preprocessor_gui.py,sha256=BUm8dsbe5LEo0FyjKrK1KdbeM75aYrS1yiCp2GfI19M,39276
-scripts/refine_matches.py,sha256=Y17Ku_t0W9vglPNF2oU5EFrqoedJIm3lCGl-hXRHvjc,21920
-tme/__init__.py,sha256=liARhKZ565F2Y02iWRbFzfrTCkL5You3YaUSiqUkees,202
-tme/__version__.py,sha256=m6kyaNpwBcP1XYcqrelX2oS3PJuOnElOcRdBa9pEb8c,22
-tme/analyzer.py,sha256=WfL6RbJDFpjwF1YiIa9NGOxEL8NddlekQIuG1r6B5fA,50325
-tme/density.py,sha256=JAC2TKzD2OWBa45MCEwT6WbL1XcTdcbiErMylwIwnH0,83837
-tme/extensions.cpython-311-darwin.so,sha256=e48Rshv8cWPSiBD-xqq5L8ekQJn84MqZse05fndMnkc,411984
-tme/matching_data.py,sha256=QvPozAnlT9GvEUaXwqmN05j-axQ5EKuoPrNBEELMxvg,25255
-tme/matching_exhaustive.py,sha256=QlFOORb2a2uDy6-wk4YU3X04y3XW4sfzwk3gC9gL27I,18843
-tme/matching_memory.py,sha256=bmCAUYyXWEet-1XXhldtc0irio2ytMSsAzWYyFI5LNM,11273
-tme/matching_optimization.py,sha256=Y8HfecXiOvAHXM1viBaQ_aXljqqTnGwlOlFe0MJpDRQ,45082
-tme/matching_scores.py,sha256=3XxvwRNztdC-4hKdloyCfwjzt4GYzA0T-WF6YUnOcvs,30867
-tme/matching_utils.py,sha256=VdQZPad9uVCQ9-32Vulh5r7bhBYylPvqv2X2DQNk91M,39736
-tme/memory.py,sha256=6xeIMAncQkgYDi6w-PIYgFEWRTUPu0_OTCeRO0p9r9Q,11029
-tme/orientations.py,sha256=Ul-1g2ci3QdRLfD447ZkcIo6Rv6f7gQH83JZcRkAru0,25384
-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=Y69k5_Vx7VpcBNV8W0pQrebzo42lp3WBfEGAl1s4Vd4,5187
-tme/backends/_jax_utils.py,sha256=v9T36Jv4ztyC38IhrbNU5tf80VKAdAXYX5ZxCWe02qU,5757
-tme/backends/cupy_backend.py,sha256=rK3pjNNB4D46MqzY2DrB_GSObFJlG5GQDOt-eOwhwTg,9429
-tme/backends/jax_backend.py,sha256=CUEJynVw9jqWid_vARMpNrhORgUR1SlLjz4ZTXkLuvI,9730
-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=QAQxr3OSq9bBN_Aq0qps-nz5vvUsx0_fFn9TocI_QCw,16988
-tme/backends/pytorch_backend.py,sha256=fzLucJZH5VYhrUtcX9osirNvLMsyMNPt_JNfS2l-kqg,14940
-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=sp3bN8JeFB2r384cEIgvN6yXjC53GCoPhBmGI0S0kbI,781
-tme/preprocessing/compose.py,sha256=tilp14UhBh98SJVJhC_STbgi7i8HeU4FB7B7KUOD8gc,1458
-tme/preprocessing/frequency_filters.py,sha256=x900ntX0QI46lDdycPISO-7K0XgM0015ksCOFlm-yM4,12964
-tme/preprocessing/tilt_series.py,sha256=Yb3dk7TZf7OfPWZPwVuFTirOZK4x6mjLbxYX9KtRBdg,34545
-pytme-0.2.2.dist-info/LICENSE,sha256=K1IUNSVAz8BXbpH5EA8y5FpaHdvFXnAF2zeK95Lr2bY,18467
-pytme-0.2.2.dist-info/METADATA,sha256=axenBTwu62Z-5jY-4kScnqv7bbWWwDU7S-VatPzSz0k,5206
-pytme-0.2.2.dist-info/WHEEL,sha256=IHsX_ZtCj0uMf8jtN3eK3zfXfu1SfKRsLbDhsprnhR0,109
-pytme-0.2.2.dist-info/entry_points.txt,sha256=ff3LQL3FCWfCYOwFiP9zatm7laUbnwCkuPELkQVyUO4,241
-pytme-0.2.2.dist-info/top_level.txt,sha256=J8FUkazOb2fZ0n_KexnqCGyNOtie2bwisFSUBiM5-0w,12
-pytme-0.2.2.dist-info/RECORD,,