diff --git a/dev/index.html b/dev/index.html index 91d61b51..980e4d18 100644 --- a/dev/index.html +++ b/dev/index.html @@ -3890,16 +3890,7 @@

Source code in imops/morphology.py - 
150
-151
-152
-153
-154
-155
-156
-157
-158
-159
+            
159
 160
 161
 162
@@ -3929,46 +3920,55 @@ 

 186
 187
 188
-189
def binary_dilation(
-    image: np.ndarray,
-    footprint: np.ndarray = None,
-    output: np.ndarray = None,
-    boxed: bool = False,
-    num_threads: int = -1,
-    backend: BackendLike = None,
-) -> np.ndarray:
-    """
-    Fast parallelizable binary morphological dilation of an image
-
-    Parameters
-    ----------
-    image: np.ndarray
-        input image
-    footprint: np.ndarray
-        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
-    output: np.ndarray
-        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
-        array is created
-    boxed: bool
-        if True, dilation is performed on cropped image which may speed up computation depedning on how localized True
-        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
-        exotic (has even shape or center pixel is False)
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` are available, `cython` is used by default
-
-    Returns
-    -------
-    dilated: np.ndarray
-        the result of morphological dilation
-
-    Examples
-    --------
-    >>> dilated = binary_dilation(x)
-    """
-    return _binary_dilation(image, footprint, output, boxed, num_threads, backend)
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
def binary_dilation(
+    image: np.ndarray,
+    footprint: np.ndarray = None,
+    output: np.ndarray = None,
+    boxed: bool = False,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Fast parallelizable binary morphological dilation of an image
+
+    Parameters
+    ----------
+    image: np.ndarray
+        input image
+    footprint: np.ndarray
+        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
+    output: np.ndarray
+        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
+        array is created
+    boxed: bool
+        if True, dilation is performed on cropped image which may speed up computation depedning on how localized True
+        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
+        exotic (has even shape or center pixel is False)
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    dilated: np.ndarray
+        the result of morphological dilation
+
+    Examples
+    --------
+    >>> dilated = binary_dilation(x)
+    """
+    return _binary_dilation(image, footprint, output, boxed, num_threads, backend)
@@ -4127,16 +4127,7 @@

Source code in imops/morphology.py - 
202
-203
-204
-205
-206
-207
-208
-209
-210
-211
+            
211
 212
 213
 214
@@ -4166,46 +4157,55 @@ 

 238
 239
 240
-241
def binary_erosion(
-    image: np.ndarray,
-    footprint: np.ndarray = None,
-    output: np.ndarray = None,
-    boxed: bool = False,
-    num_threads: int = -1,
-    backend: BackendLike = None,
-) -> np.ndarray:
-    """
-    Fast parallelizable binary morphological erosion of an image
-
-    Parameters
-    ----------
-    image: np.ndarray
-        input image
-    footprint: np.ndarray
-        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
-    output: np.ndarray
-        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
-        array is created
-    boxed: bool
-        if True, erosion is performed on cropped image which may speed up computation depedning on how localized True
-        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
-        exotic (has even shape or center pixel is False)
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` are available, `cython` is used by default
-
-    Returns
-    -------
-    eroded: np.ndarray
-        the result of morphological erosion
-
-    Examples
-    --------
-    >>> eroded = binary_erosion(x)
-    """
-    return _binary_erosion(image, footprint, output, boxed, num_threads, backend)
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
def binary_erosion(
+    image: np.ndarray,
+    footprint: np.ndarray = None,
+    output: np.ndarray = None,
+    boxed: bool = False,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Fast parallelizable binary morphological erosion of an image
+
+    Parameters
+    ----------
+    image: np.ndarray
+        input image
+    footprint: np.ndarray
+        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
+    output: np.ndarray
+        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
+        array is created
+    boxed: bool
+        if True, erosion is performed on cropped image which may speed up computation depedning on how localized True
+        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
+        exotic (has even shape or center pixel is False)
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    eroded: np.ndarray
+        the result of morphological erosion
+
+    Examples
+    --------
+    >>> eroded = binary_erosion(x)
+    """
+    return _binary_erosion(image, footprint, output, boxed, num_threads, backend)
@@ -4364,16 +4364,7 @@

Source code in imops/morphology.py - 
307
-308
-309
-310
-311
-312
-313
-314
-315
-316
+            
316
 317
 318
 319
@@ -4404,47 +4395,56 @@ 

 344
 345
 346
-347
def binary_opening(
-    image: np.ndarray,
-    footprint: np.ndarray = None,
-    output: np.ndarray = None,
-    boxed: bool = False,
-    num_threads: int = -1,
-    backend: BackendLike = None,
-) -> np.ndarray:
-    """
-    Fast parallelizable binary morphological opening of an image
-
-    Parameters
-    ----------
-    image: np.ndarray
-        input image
-    footprint: np.ndarray
-        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
-    output: np.ndarray
-        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
-        array is created
-    boxed: bool
-        if True, opening is performed on cropped image which may speed up computation depedning on how localized True
-        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
-        exotic (has even shape or center pixel is False)
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` are available, `cython` is used by default
-
-    Returns
-    -------
-    opened: np.ndarray
-        the result of morphological opening
-
-    Examples
-    --------
-    >>> opened = binary_opening(x)
-    """
-
-    return _binary_opening(image, footprint, output, boxed, num_threads, backend)
+347
+348
+349
+350
+351
+352
+353
+354
+355
+356
def binary_opening(
+    image: np.ndarray,
+    footprint: np.ndarray = None,
+    output: np.ndarray = None,
+    boxed: bool = False,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Fast parallelizable binary morphological opening of an image
+
+    Parameters
+    ----------
+    image: np.ndarray
+        input image
+    footprint: np.ndarray
+        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
+    output: np.ndarray
+        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
+        array is created
+    boxed: bool
+        if True, opening is performed on cropped image which may speed up computation depedning on how localized True
+        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
+        exotic (has even shape or center pixel is False)
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    opened: np.ndarray
+        the result of morphological opening
+
+    Examples
+    --------
+    >>> opened = binary_opening(x)
+    """
+
+    return _binary_opening(image, footprint, output, boxed, num_threads, backend)
@@ -4603,16 +4603,7 @@

Source code in imops/morphology.py - 
254
-255
-256
-257
-258
-259
-260
-261
-262
-263
+            
263
 264
 265
 266
@@ -4643,47 +4634,56 @@ 

 291
 292
 293
-294
def binary_closing(
-    image: np.ndarray,
-    footprint: np.ndarray = None,
-    output: np.ndarray = None,
-    boxed: bool = False,
-    num_threads: int = -1,
-    backend: BackendLike = None,
-) -> np.ndarray:
-    """
-    Fast parallelizable binary morphological closing of an image
-
-    Parameters
-    ----------
-    image: np.ndarray
-        input image
-    footprint: np.ndarray
-        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
-    output: np.ndarray
-        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
-        array is created
-    boxed: bool
-        if True, closing is performed on cropped image which may speed up computation depedning on how localized True
-        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
-        exotic (has even shape or center pixel is False)
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` are available, `cython` is used by default
-
-    Returns
-    -------
-    closed: np.ndarray
-        the result of morphological closing
-
-    Examples
-    --------
-    >>> closed = binary_closing(x)
-    """
-
-    return _binary_closing(image, footprint, output, boxed, num_threads, backend)
+294
+295
+296
+297
+298
+299
+300
+301
+302
+303
def binary_closing(
+    image: np.ndarray,
+    footprint: np.ndarray = None,
+    output: np.ndarray = None,
+    boxed: bool = False,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Fast parallelizable binary morphological closing of an image
+
+    Parameters
+    ----------
+    image: np.ndarray
+        input image
+    footprint: np.ndarray
+        the neighborhood expressed as a n-D array of 1's and 0's. If None, use a cross-shaped footprint (connectivity=1)
+    output: np.ndarray
+        array of the same shape as input, into which the output is placed (must be C-contiguous). By default, a new
+        array is created
+    boxed: bool
+        if True, closing is performed on cropped image which may speed up computation depedning on how localized True
+        pixels are. This may induce differences with Scikit-Image implementation at border pixels if footprint is
+        exotic (has even shape or center pixel is False)
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    closed: np.ndarray
+        the result of morphological closing
+
+    Examples
+    --------
+    >>> closed = binary_closing(x)
+    """
+
+    return _binary_closing(image, footprint, output, boxed, num_threads, backend)
diff --git a/dev/sitemap.xml.gz b/dev/sitemap.xml.gz index 1e6fc83d..47751946 100644 Binary files a/dev/sitemap.xml.gz and b/dev/sitemap.xml.gz differ