impy-array 2.4.0__tar.gz → 2.4.1__tar.gz

{impy_array-2.4.0 → impy_array-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: impy-array
-Version: 2.4.0
+Version: 2.4.1
 Summary: Speed up coding/extending image analysis in Python.
 Project-URL: Download, https://github.com/hanjinliu/impy
 Author-email: Hanjin Liu <liuhanjin-sc@g.ecc.u-tokyo.ac.jp>
@@ -76,9 +76,11 @@ Description-Content-Type: text/markdown
 
 # A numpy extension for efficient and powerful image analysis workflow
 
-`impy` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and so on.
+`impy` is an all-in-one image analysis library, equipped with parallel processing, GPU
+support, GUI-based tools and so on.
 
-The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as
+The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information
+such as:
 
 - image axes
 - scale of each axis
@@ -109,7 +111,10 @@ git clone https://github.com/hanjinliu/impy
 
 ### Code as fast as you speak
 
-Almost all the functions, such as filtering, deconvolution, labeling, single molecule detection, and even those pure `numpy` functions, are aware of image metadata. They "know" which dimension corresponds to `"z"` axis, which axes they should iterate along or where to save the image. As a result, **your code will be very concise**:
+Almost all the functions, such as filtering, deconvolution, labeling, single molecule
+detection, and even those pure `numpy` functions, are aware of image metadata. They
+"know" which dimension corresponds to `"z"` axis, which axes they should iterate along
+or where to save the image. As a result, **your code will be very concise**:
 
 ```python
 import impy as ip
@@ -124,7 +129,7 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 
 ### Supports many file formats
 
-`impy` automatically chooses proper reader/writer according to the extension.
+`impy` automatically chooses the proper reader/writer according to the extension.
 
 - Tiff file (".tif", ".tiff")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
@@ -183,8 +188,8 @@ img.imfilter(param=1.0)
 
 ### Command line usage
 
-`impy` also supports command line based image analysis. All method of `ImgArray` is available
-from commad line, such as
+`impy` also supports command-line-based image analysis. All methods of `ImgArray` are
+available from the command line, such as
 
 ```shell
 impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
@@ -199,7 +204,7 @@ out = img.gaussian_filter(sigma=2.0)
 out.imsave("./output.tif")
 ```
 
-For more complex procedure, it is possible to send image directly to `IPython`
+For more complex procedures, it is possible to send images directly to `IPython`
 
 ```
 impy path/to/image.tif -i

{impy_array-2.4.0 → impy_array-2.4.1}/README.md

@@ -4,9 +4,11 @@
 
 # A numpy extension for efficient and powerful image analysis workflow
 
-`impy` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and so on.
+`impy` is an all-in-one image analysis library, equipped with parallel processing, GPU
+support, GUI-based tools and so on.
 
-The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as
+The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information
+such as:
 
 - image axes
 - scale of each axis
@@ -37,7 +39,10 @@ git clone https://github.com/hanjinliu/impy
 
 ### Code as fast as you speak
 
-Almost all the functions, such as filtering, deconvolution, labeling, single molecule detection, and even those pure `numpy` functions, are aware of image metadata. They "know" which dimension corresponds to `"z"` axis, which axes they should iterate along or where to save the image. As a result, **your code will be very concise**:
+Almost all the functions, such as filtering, deconvolution, labeling, single molecule
+detection, and even those pure `numpy` functions, are aware of image metadata. They
+"know" which dimension corresponds to `"z"` axis, which axes they should iterate along
+or where to save the image. As a result, **your code will be very concise**:
 
 ```python
 import impy as ip
@@ -52,7 +57,7 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 
 ### Supports many file formats
 
-`impy` automatically chooses proper reader/writer according to the extension.
+`impy` automatically chooses the proper reader/writer according to the extension.
 
 - Tiff file (".tif", ".tiff")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
@@ -111,8 +116,8 @@ img.imfilter(param=1.0)
 
 ### Command line usage
 
-`impy` also supports command line based image analysis. All method of `ImgArray` is available
-from commad line, such as
+`impy` also supports command-line-based image analysis. All methods of `ImgArray` are
+available from the command line, such as
 
 ```shell
 impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
@@ -127,7 +132,7 @@ out = img.gaussian_filter(sigma=2.0)
 out.imsave("./output.tif")
 ```
 
-For more complex procedure, it is possible to send image directly to `IPython`
+For more complex procedures, it is possible to send images directly to `IPython`
 
 ```
 impy path/to/image.tif -i

{impy_array-2.4.0 → impy_array-2.4.1}/impy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.4.0"
+__version__ = "2.4.1"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 

{impy_array-2.4.0 → impy_array-2.4.1}/impy/arrays/_utils/_transform.py

@@ -10,9 +10,9 @@ if TYPE_CHECKING:
     from impy import ImgArray
 
 __all__ = [
-    "compose_affine_matrix", 
+    "compose_affine_matrix",
     "decompose_affine_matrix",
-    "affinefit", 
+    "affinefit",
     "check_matrix",
     "warp",
 ]
@@ -24,8 +24,8 @@ class AffineTransformationParameters(NamedTuple):
     shear: np.ndarray
 
 def warp(
-    img: xp.ndarray,
-    matrix: xp.ndarray,
+    img: np.ndarray,
+    matrix: np.ndarray,
     mode="constant",
     cval=0,
     output_shape=None,
@@ -35,13 +35,13 @@ def warp(
 ):
     img = xp.asarray(img, dtype=img.dtype)
     matrix = xp.asarray(matrix)
-    out = xp.ndi.affine_transform(img, matrix, cval=cval, mode=mode, output_shape=output_shape, 
+    out = xp.ndi.affine_transform(img, matrix, cval=cval, mode=mode, output_shape=output_shape,
                                   offset=offset, order=order, prefilter=prefilter)
     return out
 
-def shift(img: xp.ndarray, shift: xp.ndarray, cval=0, mode="constant", order=1, prefilter=False):
+def shift(img: np.ndarray, shift: np.ndarray, cval=0, mode="constant", order=1, prefilter=False):
     img = xp.asarray(img, dtype=img.dtype)
-    out = xp.ndi.shift(img, shift, cval=cval, mode=mode, 
+    out = xp.ndi.shift(img, shift, cval=cval, mode=mode,
                        order=order, prefilter=prefilter)
     return out
 
@@ -71,10 +71,10 @@ def compose_affine_matrix(
             translation = [translation] * ndim
         if rotation is not None:
             rotation = np.rad2deg(rotation)
-        
+
         af = Affine(scale=scale, translate=translation, rotate=rotation, shear=shear)
         mx = af.affine_matrix
-    
+
     return mx
 
 
@@ -83,12 +83,12 @@ def decompose_affine_matrix(matrix: np.ndarray):
     if ndim == 2:
         from skimage.transform import AffineTransform
         af = AffineTransform(matrix=matrix)
-        out = AffineTransformationParameters(translation=af.translation, rotation=af.rotation, 
+        out = AffineTransformationParameters(translation=af.translation, rotation=af.rotation,
                                              scale=af.scale, shear=af.shear)
     else:
         from napari.utils.transforms import Affine
         af = Affine(affine_matrix=matrix)
-        out = AffineTransformationParameters(translation=af.translate, rotation=af.rotate, 
+        out = AffineTransformationParameters(translation=af.translate, rotation=af.rotate,
                                              scale=af.scale, shear=af.shear)
     return out
 
@@ -104,8 +104,10 @@ def affinefit(img, imgref, bins=256, order=1):
     from scipy.stats import entropy
     from scipy.optimize import minimize
     from skimage.transform import warp
-    
-    as_3x3_matrix = lambda mtx: np.vstack((mtx.reshape(2,3), [0., 0., 1.]))
+
+    def as_3x3_matrix(mtx: np.ndarray):
+        return np.vstack((mtx.reshape(2,3), [0., 0., 1.]))
+
     def normalized_mutual_information(img, imgref):
         """
         Y(A,B) = (H(A)+H(B))/H(A,B)
@@ -117,15 +119,15 @@ def affinefit(img, imgref, bins=256, order=1):
         e2 = entropy(np.sum(hist, axis=1))
         e12 = entropy(np.ravel(hist)) # mutual entropy
         return (e1 + e2)/e12
-    
+
     def cost_nmi(mtx, img, imgref):
         mtx = as_3x3_matrix(mtx)
         img_transformed = warp(img, mtx, order=order)
         return -normalized_mutual_information(img_transformed, imgref)
-    
+
     mtx0 = np.array([[1., 0., 0.],
                      [0., 1., 0.]]) # aberration makes little difference
-    
+
     result = minimize(
         cost_nmi, mtx0, args=(np.asarray(img), np.asarray(imgref)), method="Powell"
     )
@@ -134,24 +136,24 @@ def affinefit(img, imgref, bins=256, order=1):
 
 
 def check_matrix(matrices: list[np.ndarray | float]):
-    """Check Affine transformation matrix."""    
+    """Check Affine transformation matrix."""
     mtx = []
     for m in matrices:
-        if np.isscalar(m): 
+        if np.isscalar(m):
             if m == 1:
                 mtx.append(m)
             else:
                 raise ValueError(f"Only `1` is ok, but got {m}")
-            
+
         elif m.shape != (3, 3) or not np.allclose(m[2,:2], 0):
             raise ValueError(f"Wrong Affine transformation matrix:\n{m}")
-        
+
         else:
             mtx.append(m)
     return mtx
 
 def polar2d(
-    img: xp.ndarray,
+    img: np.ndarray,
     rmax: int,
     dtheta: float = 0.1,  # radian
     order: int = 1,
@@ -170,14 +172,14 @@ def polar2d(
     return out
 
 def normalize_radon_input(
-    self: ImgArray, 
-    dims: Axes, 
-    central_axis: AxisLike, 
+    self: ImgArray,
+    dims: Axes,
+    central_axis: AxisLike,
     degrees: Sequence[float] | float,
-):    
+):
     ndim = len(dims)
     squeeze = not hasattr(degrees, "__iter__")
-    
+
     if squeeze:
         degrees = [degrees]
     if ndim != self.ndim:
@@ -213,7 +215,7 @@ def normalize_radon_input(
             central_axis: np.ndarray
             if central_axis.shape != (ndim,):
                 raise ValueError(f"Image is {ndim}D but central_axis is {central_axis.ndim}D.")
-        
+
         # construct Affine transform matrices
         height = int(np.ceil(np.linalg.norm(self.shape)))
         output_shape = (height, self.shape[1], self.shape[2])
@@ -222,11 +224,11 @@ def normalize_radon_input(
         )
     else:
         raise ValueError("Only 2D or 3D input is supported.")
-    
+
     return params, output_shape, squeeze
 
 def normalize_iradon_input(
-    self: ImgArray, 
+    self: ImgArray,
     central_axis: AxisLike,
     height_axis: AxisLike,
     degree_axis: AxisLike,
@@ -250,7 +252,7 @@ def normalize_iradon_input(
     output_shape = (height, self.shape[-1])
     return central_axis, degree_axis, output_shape, new_axes
 
-def radon_single(img: xp.ndarray, mtx: np.ndarray, order: int = 3, output_shape=None):
+def radon_single(img: np.ndarray, mtx: np.ndarray, order: int = 3, output_shape=None):
     """Radon transform of 2D image."""
     img_rot = warp(img, mtx, order=order, output_shape=output_shape, prefilter=False)
     return xp.sum(img_rot, axis=0)
@@ -290,13 +292,13 @@ def _get_rotation_matrices_for_radon_3d(
     return np.einsum("ij,njk,kl->nil", tr_0, rotation, tr_1)
 
 # This function is mostly ported from `skimage.transform`.
-# The most important difference is that this implementation support arbitrary 
+# The most important difference is that this implementation support arbitrary
 # output shape.
 def iradon(
-    img: xp.ndarray, 
-    degrees: xp.ndarray,
+    img: np.ndarray,
+    degrees: np.ndarray,
     output_shape: tuple[int, int],
-    filter_func: xp.ndarray,
+    filter_func: np.ndarray,
     interp: Callable[[np.ndarray, np.ndarray], np.ndarray],
 ):
     angles_count = len(degrees)
@@ -322,7 +324,7 @@ def iradon(
 
     return reconstructed * np.pi / (2 * angles_count)
 
-# This function is almost ported from `skimage.transform`, but create a ramp 
+# This function is almost ported from `skimage.transform`, but create a ramp
 # filter in a simpler way.
 def get_fourier_filter(size: int, filter_name: str):
     # ramp filter

{impy_array-2.4.0 → impy_array-2.4.1}/impy/arrays/imgarray.py

@@ -221,60 +221,78 @@ class ImgArray(LabeledArray):
     @_docs.write_docs
     @dims_to_spatial_axes
     @same_dtype(asfloat=True)
-    def rescale(
+    def zoom(
         self,
-        scale: nDFloat = 1/16,
+        zoom: nDFloat,
         *,
-        order: int = None,
-        mode: PaddingMode = "reflect",
+        order: int = 3,
+        mode: PaddingMode = "constant",
         cval: float = 0.0,
+        same_shape: bool = False,
         dims: Dims = None,
     ) -> ImgArray:
         """
-        Rescale image by applying the diagonal component of Affine matrix.
+        Zoom image by applying the diagonal component of Affine matrix.
 
         Parameters
         ----------
-        scale : float, optional
+        scale : float
             Relative scale of the new image. scale 1/2 means that the shape of
             the output image will be (N/2, ...).
         {order}{mode}{cval}{dims}
+        same_shape : bool, default is False
+            If True, the output image will have the same shape as the input image.
 
         Returns
         -------
         ImgArray
             Rescaled image.
         """
-        from skimage.transform import rescale
-        scale_is_seq = hasattr(scale, "__iter__")
+        zoom_is_seq = hasattr(zoom, "__iter__")
 
         # Check if output is too large.
         gb = -1
-        if not scale_is_seq and scale > 1:
-            gb = np.prod(self.shape) * (scale ** len(dims)) / 2**30
-        elif scale_is_seq and np.prod(list(scale)) > 1:
-            gb = np.prod(self.shape) * np.prod(list(scale)) / 2**30
+        if not zoom_is_seq and zoom > 1:
+            gb = np.prod(self.shape) * (zoom ** len(dims)) / 2**30 * self.itemsize
+        elif zoom_is_seq and np.prod(list(zoom)) > 1:
+            gb = np.prod(self.shape) * np.prod(list(zoom)) / 2**30 * self.itemsize
         if gb > Const["MAX_GB"]:
             raise MemoryError(f"Output image is too large: {gb} GB")
 
-        if scale_is_seq:
-            scale = list(scale)
-            if len(scale) != len(dims):
+        if zoom_is_seq:
+            zoom = list(zoom)
+            if len(zoom) != len(dims):
                 raise ValueError(
                     "scale must have the same length as the spatial dimensions."
                 )
-            it = iter(scale)
-            scale_ = [next(it) if a in dims else 1 for a in self.axes]
+            it = iter(zoom)
+            zoom_ = [next(it) if a in dims else 1 for a in self.axes]
         else:
-            scale_ = [scale if a in dims else 1 for a in self.axes]
-        out = rescale(
-            self.value, scale_, order=order, mode=mode, cval=cval, anti_aliasing=False
-        )
-        out = out.view(self.__class__)._set_info(self)
+            zoom_ = [zoom if a in dims else 1 for a in self.axes]
+
+        if not same_shape:
+            if mode == "constant":
+                mode = "grid-constant"
+            out = ndi.zoom(
+                self.value, zoom_, order=order, mode=mode, cval=cval,
+                prefilter=order > 1, grid_mode=True,
+            ).view(self.__class__)._set_info(self)
+        else:
+            center = [(s - 1) / 2 for s in self.sizesof(dims)]
+            mesh = np.meshgrid(
+                *[
+                    (np.arange(_s) - _c) / _z + _c
+                    for _s, _z, _c in zip(self.sizesof(dims), zoom_, center)
+                ],
+                indexing="ij",
+            )
+            out = self.map_coordinates(mesh, order=order, mode=mode, cval=cval, dims=dims)
         out.axes = self.axes.copy()
-        out.set_scale({a: self.scale[a]/scale for a, scale in zip(self.axes, scale_)})
+        out.set_scale({a: self.scale[a]/scale for a, scale in zip(self.axes, zoom_)})
         return out
 
+    rescale = zoom  # backward compatibility
+
     @_docs.write_docs
     @dims_to_spatial_axes
     @same_dtype
@@ -465,10 +483,10 @@ class ImgArray(LabeledArray):
             out.metadata["GaussianParameters"] = params
             return out
 
-        rough = self.rescale(scale).value.astype(np.float32)
+        rough = self.zoom(scale, mode="reflect", order=1).value.astype(np.float32)
         if mask is not None:
-            from ..core import asarray as ip_asarray
-            mask = ip_asarray(mask).rescale(scale) > 0
+            from impy.core import asarray as ip_asarray
+            mask = ip_asarray(mask).zoom(scale, mode="reflect", order=1) > 0
         gaussian = GaussianBackground(p0)
         gaussian.fit(rough, method=method, mask=mask)
         gaussian.rescale(1/scale)
@@ -480,12 +498,18 @@ class ImgArray(LabeledArray):
 
     @same_dtype(asfloat=True)
     @check_input_and_output
-    def gauss_correction(self, ref: ImgArray=None, scale: float = 1/16, median_radius: float = 15):
+    def gauss_correction(
+        self,
+        ref: ImgArray | None = None,
+        scale: float = 1/16,
+        median_radius: float = 15,
+    ):
         """
-        Correct unevenly distributed excitation light using Gaussian fitting. This method subtracts
-        background intensity at the same time. If input image is uint, then output value under 0 will
-        replaced with 0. If you want to quantify background, it is necessary to first convert input
-        image to float image.
+        Correct unevenly distributed excitation light using Gaussian fitting.
+
+        This method subtracts background intensity at the same time. If input image is
+        uint, then output value under 0 will replaced with 0. If you want to quantify
+        background, it is necessary to first convert input image to float image.
 
         Parameters
         ----------
@@ -1069,7 +1093,6 @@ class ImgArray(LabeledArray):
             kwargs=dict(footprint=disk, mode=mode, cval=cval)
         )
 
-
     @_docs.write_docs
     @dims_to_spatial_axes
     @check_input_and_output(only_binary=True)
@@ -1321,7 +1344,9 @@ class ImgArray(LabeledArray):
     @check_input_and_output
     def entropy_filter(self, radius: nDFloat = 5, *, dims: Dims = None) -> ImgArray:
         """
-        Running entropy filter. This filter is useful for detecting change in background distribution.
+        Running entropy filter.
+
+        This filter is useful for detecting change in background distribution.
 
         Parameters
         ----------
@@ -1413,8 +1438,10 @@ class ImgArray(LabeledArray):
     def kalman_filter(self, gain: float = 0.8, noise_var: float = 0.05, *, along: str = "t",
                       dims: Dims = None, update: bool = False) -> ImgArray:
         """
-        Kalman filter for image smoothing. This function is same as "Kalman Stack Filter" in ImageJ but support
-        batch processing. This filter is useful for preprocessing of particle tracking.
+        Kalman filter for image smoothing.
+
+        This function is same as "Kalman Stack Filter" in ImageJ but support batch
+        processing. This filter is useful for preprocessing of particle tracking.
 
         Parameters
         ----------
@@ -1450,8 +1477,10 @@ class ImgArray(LabeledArray):
     @check_input_and_output
     def focus_map(self, radius: int = 1, *, dims: Dims = 2) -> PropArray:
         """
-        Compute focus map using variance of Laplacian method. yx-plane with higher variance is likely a
-        focal plane because sharper image causes higher value of Laplacian on the edges.
+        Compute focus map using variance of Laplacian method.
+
+        yx-plane with higher variance is likely a focal plane because sharper image
+        causes higher value of Laplacian on the edges.
 
         Parameters
         ----------
@@ -1626,8 +1655,10 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
     ) -> ImgArray:
         """
-        Run Difference of Gaussian filter. This function does not support `update`
-        argument because intensity can be negative.
+        Run Difference of Gaussian filter.
+
+        This function does not support `update` argument because intensity can be
+        negative.
 
         Parameters
         ----------
@@ -2809,11 +2840,12 @@ class ImgArray(LabeledArray):
         dtype = np.complex128 if double_precision else np.complex64
 
         # Calculate exp(-ikx)
-        # To minimize floating error, the A term in exp(-2*pi*i*A) should be in the range of
-        # 0 <= A < 1.
-        exps: list[xp.ndarray] = \
-            [xp.exp(-2j * np.pi * xp.mod(wave_num(sl, s, uf) * xp.arange(s)/s, 1.), dtype=dtype)
-             for sl, s, uf in zip(slices, self.sizesof(dims), upsample_factor)]
+        # To minimize floating error, the A term in exp(-2*pi*i*A) should be in the
+        # range of 0 <= A < 1.
+        exps: list[np.ndarray] = [
+            xp.exp(-2j * np.pi * xp.mod(wave_num(sl, s, uf) * xp.arange(s)/s, 1.), dtype=dtype)
+            for sl, s, uf in zip(slices, self.sizesof(dims), upsample_factor)
+        ]
 
         # Calculate chunk size for proper output shapes
         out_chunks = np.ones(self.ndim, dtype=np.int64)
@@ -3859,7 +3891,7 @@ class ImgArray(LabeledArray):
 
         out = self.view(np.ndarray).astype(np.float32)
         lowerlim, upperlim = _check_clip_range(in_range, self.value)
-        out = rescale_intensity(out, in_range=(lowerlim, upperlim), out_range="dtype")
+        out = rescale_intensity(out, in_range=(lowerlim, upperlim), out_range=dtype)
         out = out.view(self.__class__)
         return out
 
@@ -4538,13 +4570,13 @@ def _specify_one(center, radius, shape:tuple) -> tuple[slice]:
 
 def check_filter_func(f):
     if f is None:
-        f = lambda x: True
+        return lambda x: True
     elif not callable(f):
         raise TypeError("`filt` must be callable.")
     return f
 
 
-def wave_num(sl: slice, s: int, uf: int) -> xp.ndarray:
+def wave_num(sl: slice, s: int, uf: int) -> np.ndarray:
     """
     A function that makes wave number vertical vector. Returned vector will
     be [k/s, (k + 1/uf)/s, (k + 2/uf)/s, ...] (where k = sl.start)

{impy_array-2.4.0 → impy_array-2.4.1}/impy/io.py

@@ -373,7 +373,6 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         img_dask = _rechunk_to_ones(img.value)
         writer = _MemmapArrayWriter(path, mmap.offset, img.shape, img_dask.chunksize)
         da.store(img_dask, writer)
-        mmap.flush()
         return
 
     from tifffile import imwrite
@@ -471,7 +470,6 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         img_dask = _rechunk_to_ones(img.value)
         writer = _MemmapArrayWriter(path, mrc_mmap.data.offset, img.shape, img_dask.chunksize)
         da.store(img_dask, writer)
-        mrc_mmap.flush()
         return None
 
     # get voxel_size
@@ -739,12 +737,13 @@ class _MemmapArrayWriter:
         # sl = (0:1, 16:32, 0:1000, 0:1000)
 
         offset = np.sum([sl[i].start * arr.strides[i] for i in range(self._border + 1)])
+        arr_ravel = arr.ravel()
         mmap = np.memmap(
             self._path,
             mode="r+",
             offset=self._offset + offset,
+            shape=arr_ravel.shape,
             dtype=arr.dtype,
         )
-        arr_ravel = arr.ravel()
         mmap[:arr_ravel.size] = arr_ravel
         mmap.flush()

{impy_array-2.4.0 → impy_array-2.4.1}/impy/utils/gauss.py

@@ -21,11 +21,11 @@ def diagonal_gaussian(r, *params):
     sg = params[ndim:-2]
     z_value = np.array([(x0 - mu0)/sg0 for x0, mu0, sg0 in zip(r, mu, sg)])
     return a * np.exp(-np.sum(z_value**2, axis=0) / 2) + b
-    
+
 class Gaussian:
     def mu_inrange(self, low, high):
         return np.logical_and(low<=self.mu, self.mu<=high).all()
-    
+
     def sg_inrange(self, low, high):
         sg_ = np.abs(self.sg)
         return np.logical_and(low<=sg_, sg_<=high).all()
@@ -36,40 +36,40 @@ class DiagonalGaussian(Gaussian):
             self.mu = self.sg = self.a = self.b = None
         else:
             self.mu, self.sg, self.a, self.b = params
-    
+
     @property
     def mu(self):
         return self._mu
-    
+
     @mu.setter
     def mu(self, value):
         if value is None:
             self._mu = None
         else:
             self._mu = np.asarray(value)
-        
+
     @property
     def sg(self):
         return self._sg
-    
+
     @sg.setter
     def sg(self, value):
         if value is None:
             self._sg = None
         else:
             self._sg = np.asarray(value)
-        
-    @property    
+
+    @property
     def params(self):
         """Get flattened parameters."""
         return tuple(self.mu) + tuple(self.sg) + (self.a, self.b)
-    
+
     @params.setter
     def params(self, params:tuple):
         self.a, self.b = params[-2:]
         self.mu = params[:self.ndim]
         self.sg = params[self.ndim:-2]
-    
+
     def asdict(self) -> dict[str, Any]:
         return {
             "mu": self.mu.tolist(),
@@ -77,12 +77,17 @@ class DiagonalGaussian(Gaussian):
             "A": self.a,
             "B": self.b,
         }
-    
+
     @property
     def ndim(self):
         return self.mu.size
-    
-    def fit(self, data: np.ndarray, method: str = "Powell", mask: np.ndarray | None = None):
+
+    def fit(
+        self,
+        data: np.ndarray,
+        method: str = "Powell",
+        mask: np.ndarray | None = None,
+    ):
         from scipy.optimize import minimize
         if self.mu is None or self.sg is None or self.a is None or self.b is None:
             if mask is not None:
@@ -92,7 +97,7 @@ class DiagonalGaussian(Gaussian):
             else:
                 self._estimate_params(data)
         r = np.indices(data.shape)
-        
+
         if mask is None:
             result = minimize(
                 square,
@@ -112,30 +117,30 @@ class DiagonalGaussian(Gaussian):
                 method=method
             )
         self.params = result.x
-        
+
         return result
-            
+
     def rescale(self, scale: float):
         self.mu *= scale
         self.sg *= scale
         return None
-    
+
     def shift(self, dxdy):
         self.mu += np.array(dxdy)
         return None
-    
+
     def generate(self, shape:tuple) -> np.ndarray:
         r = np.indices(shape, dtype=np.float32)
         return diagonal_gaussian(r, *self.params)
-    
-    def _estimate_params(self, data:np.ndarray):
+
+    def _estimate_params(self, data: np.ndarray):
         pass
 
 class GaussianParticle(DiagonalGaussian):
     def __init__(self, params=None, initial_sg=1):
         super().__init__(params)
         self.initial_sg = initial_sg
-        
+
     def _estimate_params(self, data:np.ndarray):
         # n-dim argmax
         self.mu = np.array(np.unravel_index(np.argmax(data), data.shape), dtype="float32")
@@ -151,4 +156,4 @@ class GaussianBackground(DiagonalGaussian):
         self.sg = np.array(data.shape, dtype="float32")
         self.b, p95 = np.percentile(data, [5, 95])
         self.a = p95 - self.b
-        return None
+        return None