# encoding: utf-8 # module dipy.denoise.enhancement_kernel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\dipy\denoise\enhancement_kernel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import builtins as __builtins__ # import numpy as np # C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\numpy\__init__.py import os as os # C:\Programs\Python\Python311\Lib\os.py import logging as logging # C:\Programs\Python\Python311\Lib\logging\__init__.py from math import ceil import dipy.core.sphere as __dipy_core_sphere # functions def disperse_charges(hemi, iters, const=0.2): # reliably restored by inspect """ Models electrostatic repulsion on the unit sphere Places charges on a sphere and simulates the repulsive forces felt by each one. Allows the charges to move for some number of iterations and returns their final location as well as the total potential of the system at each step. Parameters ---------- hemi : HemiSphere Points on a unit sphere. iters : int Number of iterations to run. const : float Using a smaller const could provide a more accurate result, but will need more iterations to converge. Returns ------- hemi : HemiSphere Distributed points on a unit sphere. potential : ndarray The electrostatic potential at each iteration. This can be useful to check if the repulsion converged to a minimum. Notes ----- This function is meant to be used with diffusion imaging so antipodal symmetry is assumed. Therefore, each charge must not only be unique, but if there is a charge at +x, there cannot be a charge at -x. These are treated as the same location and because the distance between the two charges will be zero, the result will be unstable. """ pass def gettempdir(): # reliably restored by inspect """ Returns tempfile.tempdir as str. """ pass def get_sphere(name=None): # reliably restored by inspect """ provide triangulated spheres Parameters ---------- name : str which sphere - one of: * 'symmetric362' * 'symmetric642' * 'symmetric724' * 'repulsion724' * 'repulsion100' * 'repulsion200' Returns ------- sphere : a dipy.core.sphere.Sphere class instance Examples -------- >>> import numpy as np >>> from dipy.data import get_sphere >>> sphere = get_sphere('symmetric362') >>> verts, faces = sphere.vertices, sphere.faces >>> verts.shape == (362, 3) True >>> faces.shape == (720, 3) True >>> verts, faces = get_sphere('not a sphere name') #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... DataError: No sphere called "not a sphere name" """ pass def __pyx_unpickle_EnhancementKernel(*args, **kwargs): # real signature unknown pass def __pyx_unpickle_Enum(*args, **kwargs): # real signature unknown pass # classes class EnhancementKernel(object): # no doc def evaluate_kernel(self, *args, **kwargs): # real signature unknown """ Evaluate the kernel at position x relative to position y, with orientation r relative to orientation v. Parameters ---------- x : 1D ndarray Position x y : 1D ndarray Position y r : 1D ndarray Orientation r v : 1D ndarray Orientation v Returns ------- kernel_value : double """ pass def get_lookup_table(self, *args, **kwargs): # real signature unknown """ Return the computed look-up table. """ pass def get_orientations(self, *args, **kwargs): # real signature unknown """ Return the orientations. """ pass def get_sphere(self, *args, **kwargs): # real signature unknown """ Get the sphere corresponding with the orientations """ pass def __init__(self, *args, **kwargs): # real signature unknown """ Compute a look-up table for the contextual enhancement kernel Parameters ---------- D33 : float Spatial diffusion D44 : float Angular diffusion t : float Diffusion time force_recompute : boolean Always compute the look-up table even if it is available in cache. Default is False. orientations : integer or Sphere object Specify the number of orientations to be used with electrostatic repulsion, or provide a Sphere object. The default sphere is 'repulsion100'. verbose : boolean Enable verbose mode. References ---------- [Meesters2016_ISMRM] S. Meesters, G. Sanguinetti, E. Garyfallidis, J. Portegies, R. Duits. (2016) Fast implementations of contextual PDE’s for HARDI data processing in DIPY. ISMRM 2016 conference. [DuitsAndFranken_IJCV] R. Duits and E. Franken (2011) Left-invariant diffusions on the space of positions and orientations and their application to crossing-preserving smoothing of HARDI images. International Journal of Computer Vision, 92:231-264. [Portegies2015] J. Portegies, G. Sanguinetti, S. Meesters, and R. Duits. (2015) New Approximation of a Scale Space Kernel on SE(3) and Applications in Neuroimaging. Fifth International Conference on Scale Space and Variational Methods in Computer Vision [Portegies2015b] J. Portegies, R. Fick, G. Sanguinetti, S. Meesters, G. Girard, and R. Duits. (2015) Improving Fiber Alignment in HARDI by Combining Contextual PDE flow with Constrained Spherical Deconvolution. PLoS One. """ pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown pass def __setstate__(self, *args, **kwargs): # real signature unknown pass __pyx_vtable__ = None # (!) real value is '' class Sphere(object): """ Points on the unit sphere. The sphere can be constructed using one of three conventions:: Sphere(x, y, z) Sphere(xyz=xyz) Sphere(theta=theta, phi=phi) Parameters ---------- x, y, z : 1-D array_like Vertices as x-y-z coordinates. theta, phi : 1-D array_like Vertices as spherical coordinates. Theta and phi are the inclination and azimuth angles respectively. xyz : (N, 3) ndarray Vertices as x-y-z coordinates. faces : (N, 3) ndarray Indices into vertices that form triangular faces. If unspecified, the faces are computed using a Delaunay triangulation. edges : (N, 2) ndarray Edges between vertices. If unspecified, the edges are derived from the faces. """ def edges(self): # reliably restored by inspect # no doc pass def faces(self): # reliably restored by inspect # no doc pass def find_closest(self, xyz): # reliably restored by inspect """ Find the index of the vertex in the Sphere closest to the input vector Parameters ---------- xyz : array-like, 3 elements A unit vector Returns ------- idx : int The index into the Sphere.vertices array that gives the closest vertex (in angle). """ pass def subdivide(self, n=1): # reliably restored by inspect """ Subdivides each face of the sphere into four new faces. New vertices are created at a, b, and c. Then each face [x, y, z] is divided into faces [x, a, c], [y, a, b], [z, b, c], and [a, b, c]. :: y /\ / \ a/____\b /\ /\ / \ / \ /____\/____\ x c z Parameters ---------- n : int, optional The number of subdivisions to preform. Returns ------- new_sphere : Sphere The subdivided sphere. """ pass def vertices(self): # reliably restored by inspect # no doc pass def __init__(self, x=None, y=None, z=None, theta=None, phi=None, xyz=None, faces=None, edges=None): # reliably restored by inspect # no doc pass x = property(lambda self: object(), lambda self, v: None, lambda self: None) # default y = property(lambda self: object(), lambda self, v: None, lambda self: None) # default z = property(lambda self: object(), lambda self, v: None, lambda self: None) # default __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """list of weak references to the object (if defined)""" __dict__ = None # (!) real value is "mappingproxy({'__module__': 'dipy.core.sphere', '__doc__': 'Points on the unit sphere.\\n\\n The sphere can be constructed using one of three conventions::\\n\\n Sphere(x, y, z)\\n Sphere(xyz=xyz)\\n Sphere(theta=theta, phi=phi)\\n\\n Parameters\\n ----------\\n x, y, z : 1-D array_like\\n Vertices as x-y-z coordinates.\\n theta, phi : 1-D array_like\\n Vertices as spherical coordinates. Theta and phi are the inclination\\n and azimuth angles respectively.\\n xyz : (N, 3) ndarray\\n Vertices as x-y-z coordinates.\\n faces : (N, 3) ndarray\\n Indices into vertices that form triangular faces. If unspecified,\\n the faces are computed using a Delaunay triangulation.\\n edges : (N, 2) ndarray\\n Edges between vertices. If unspecified, the edges are\\n derived from the faces.\\n\\n ', '__init__': , 'vertices': , 'x': , 'y': , 'z': , 'faces': , 'edges': , 'subdivide': , 'find_closest': , '__dict__': , '__weakref__': })" class HemiSphere(__dipy_core_sphere.Sphere): """ Points on the unit sphere. A HemiSphere is similar to a Sphere but it takes antipodal symmetry into account. Antipodal symmetry means that point v on a HemiSphere is the same as the point -v. Duplicate points are discarded when constructing a HemiSphere (including antipodal duplicates). `edges` and `faces` are remapped to the remaining points as closely as possible. The HemiSphere can be constructed using one of three conventions:: HemiSphere(x, y, z) HemiSphere(xyz=xyz) HemiSphere(theta=theta, phi=phi) Parameters ---------- x, y, z : 1-D array_like Vertices as x-y-z coordinates. theta, phi : 1-D array_like Vertices as spherical coordinates. Theta and phi are the inclination and azimuth angles respectively. xyz : (N, 3) ndarray Vertices as x-y-z coordinates. faces : (N, 3) ndarray Indices into vertices that form triangular faces. If unspecified, the faces are computed using a Delaunay triangulation. edges : (N, 2) ndarray Edges between vertices. If unspecified, the edges are derived from the faces. tol : float Angle in degrees. Vertices that are less than tol degrees apart are treated as duplicates. See Also -------- Sphere """ def faces(self): # reliably restored by inspect # no doc pass def find_closest(self, xyz): # reliably restored by inspect """ Find the index of the vertex in the Sphere closest to the input vector, taking into account antipodal symmetry Parameters ---------- xyz : array-like, 3 elements A unit vector Returns ------- idx : int The index into the Sphere.vertices array that gives the closest vertex (in angle). """ pass @classmethod def from_sphere(cls, *args, **kwargs): # real signature unknown """ Create instance from a Sphere """ pass def mirror(self): # reliably restored by inspect """ Create a full Sphere from a HemiSphere """ pass def subdivide(self, n=1): # reliably restored by inspect """ Create a more subdivided HemiSphere See Sphere.subdivide for full documentation. """ pass def __init__(self, x=None, y=None, z=None, theta=None, phi=None, xyz=None, faces=None, edges=None, tol=1e-05): # reliably restored by inspect """ Create a HemiSphere from points """ pass # variables with complex values logger = None # (!) real value is '' __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x0000015FAD81F050>' __spec__ = None # (!) real value is "ModuleSpec(name='dipy.denoise.enhancement_kernel', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x0000015FAD81F050>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\dipy\\\\denoise\\\\enhancement_kernel.cp311-win_amd64.pyd')" __test__ = {}