remove deprecated square, rectangle and cube (replaced by footprint_rectangle) (#969)

Removing a few functions that we missed doing the scheduled removal for during the 25.08 release.

Authors:
  - Gregory Lee (https://github.com/grlee77)
  - https://github.com/jakirkham

Approvers:
  - https://github.com/jakirkham

URL: #969

Author: grlee77

python/cucim/src/cucim/skimage/morphology/__init__.py

@@ -17,15 +17,12 @@
 )
 from .footprints import (
     ball,
-    cube,
     diamond,
     disk,
     footprint_from_sequence,
     footprint_rectangle,
     octagon,
     octahedron,
-    rectangle,
-    square,
     star,
 )
 from .gray import (

python/cucim/src/cucim/skimage/morphology/footprints.py

@@ -11,7 +11,6 @@
 import numpy as np
 
 from cucim.skimage import morphology
-from cucim.skimage._shared.utils import deprecate_func
 
 # Precomputed ball and disk decompositions were saved as 2D arrays where the
 # radius of the desired decomposition is used to index into the first axis of
@@ -223,71 +222,6 @@ def partial_footprint(dim, width):
     return footprint
 
 
-@deprecate_func(
-    deprecated_version="25.02",
-    removed_version="25.08",
-    hint="Use `cucim.skimage.morphology.footprint_rectangle` instead.",
-)
-def square(width, dtype=None, *, decomposition=None):
-    """Generates a flat, square-shaped footprint.
-
-    Every pixel along the perimeter has a chessboard distance
-    no greater than radius (radius=floor(width/2)) pixels.
-
-    Parameters
-    ----------
-    width : int
-        The width and height of the square.
-
-    Other Parameters
-    ----------------
-    dtype : data-type or None, optional
-        The data type of the footprint. When None, a tuple will be returned in
-        place of the actual footprint array. This can be be passed to grayscale
-        and binary morphology functions in place of an explicit array to avoid
-        array allocation overhead.
-    decomposition : {None, 'separable', 'sequence'}, optional
-        If None, a single array is returned. For 'sequence', a tuple of smaller
-        footprints is returned. Applying this series of smaller footprints will
-        give an identical result to a single, larger footprint, but often with
-        better computational performance. See Notes for more details.
-        With 'separable', this function uses separable 1D footprints for each
-        axis. Whether 'sequence' or 'separable' is computationally faster may
-        be architecture-dependent.
-
-    Returns
-    -------
-    footprint : cupy.ndarray
-        The footprint where elements of the neighborhood are 1 and 0 otherwise.
-        When `decomposition` is None, this is just a numpy.ndarray. Otherwise,
-        this will be a tuple whose length is equal to the number of unique
-        structuring elements to apply (see Notes for more detail)
-
-    Notes
-    -----
-    When `decomposition` is not None, each element of the `footprint`
-    tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a
-    footprint array and the number of iterations it is to be applied.
-
-    For binary morphology, using ``decomposition='sequence'`` or
-    ``decomposition='separable'`` were observed to give better performance than
-    ``decomposition=None``, with the magnitude of the performance increase
-    rapidly increasing with footprint size. For grayscale morphology with
-    square footprints, it is recommended to use ``decomposition=None`` since
-    the internal SciPy functions that are called already have a fast
-    implementation based on separable 1D sliding windows.
-
-    The 'sequence' decomposition mode only supports odd valued `width`. If
-    `width` is even, the sequence used will be identical to the 'separable'
-    mode.
-
-    """
-    footprint = footprint_rectangle(
-        shape=(width, width), dtype=dtype, decomposition=decomposition
-    )
-    return footprint
-
-
 def _decompose_size(size, kernel_size=3):
     """Determine number of repeated iterations for a `kernel_size` kernel.
 
@@ -301,75 +235,6 @@ def _decompose_size(size, kernel_size=3):
     return 1 + (size - kernel_size) // (kernel_size - 1)
 
 
-@deprecate_func(
-    deprecated_version="25.02",
-    removed_version="25.08",
-    hint="Use `cucim.skimage.morphology.footprint_rectangle` instead.",
-)
-def rectangle(nrows, ncols, dtype=None, *, decomposition=None):
-    """Generates a flat, rectangular-shaped footprint.
-
-    Every pixel in the rectangle generated for a given width and given height
-    belongs to the neighborhood.
-
-    Parameters
-    ----------
-    nrows : int
-        The number of rows of the rectangle.
-    ncols : int
-        The number of columns of the rectangle.
-
-    Other Parameters
-    ----------------
-    dtype : data-type or None, optional
-        The data type of the footprint. When None, a tuple will be returned in
-        place of the actual footprint array. This can be be passed to grayscale
-        and binary morphology functions in place of an explicit array to avoid
-        array allocation overhead.
-    decomposition : {None, 'separable', 'sequence'}, optional
-        If None, a single array is returned. For 'sequence', a tuple of smaller
-        footprints is returned. Applying this series of smaller footprints will
-        given an identical result to a single, larger footprint, but often with
-        better computational performance. See Notes for more details.
-        With 'separable', this function uses separable 1D footprints for each
-        axis. Whether 'seqeunce' or 'separable' is computationally faster may
-        be architecture-dependent.
-
-    Returns
-    -------
-    footprint : cupy.ndarray
-        A footprint consisting only of ones, i.e. every pixel belongs to the
-        neighborhood. When `decomposition` is None, this is just a
-        numpy.ndarray. Otherwise, this will be a tuple whose length is equal to
-        the number of unique structuring elements to apply (see Notes for more
-        detail)
-
-    Notes
-    -----
-    When `decomposition` is not None, each element of the `footprint`
-    tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a
-    footprint array and the number of iterations it is to be applied.
-
-    For binary morphology, using ``decomposition='sequence'``
-    was observed to give better performance, with the magnitude of the
-    performance increase rapidly increasing with footprint size. For grayscale
-    morphology with rectangular footprints, it is recommended to use
-    ``decomposition=None`` since the internal SciPy functions that are called
-    already have a fast implementation based on separable 1D sliding windows.
-
-    The `sequence` decomposition mode only supports odd valued `nrows` and
-    `ncols`. If either `nrows` or `ncols` is even, the sequence used will be
-    identical to ``decomposition='separable'``.
-
-    - The use of ``width`` and ``height`` has been deprecated in
-      version 0.18.0. Use ``nrows`` and ``ncols`` instead.
-    """
-    footprint = footprint_rectangle(
-        shape=(nrows, ncols), dtype=dtype, decomposition=decomposition
-    )
-    return footprint
-
-
 def diamond(radius, dtype=cp.uint8, *, decomposition=None):
     """Generates a flat, diamond-shaped footprint.
 
@@ -768,67 +633,6 @@ def ellipse(width, height, dtype=cp.uint8, *, decomposition=None):
     return sequence
 
 
-@deprecate_func(
-    deprecated_version="25.02",
-    removed_version="25.08",
-    hint="Use `cucim.skimage.morphology.footprint_rectangle` instead.",
-)
-def cube(width, dtype=None, *, decomposition=None):
-    """Generates a cube-shaped footprint.
-
-    This is the 3D equivalent of a square.
-    Every pixel along the perimeter has a chessboard distance
-    no greater than radius (radius=floor(width/2)) pixels.
-
-    Parameters
-    ----------
-    width : int
-        The width, height and depth of the cube.
-
-    Other Parameters
-    ----------------
-    dtype : data-type or None, optional
-        The data type of the footprint. When None, a tuple will be returned in
-        place of the actual footprint array. This can be be passed to grayscale
-        and binary morphology functions in place of an explicit array to avoid
-        array allocation overhead.
-    decomposition : {None, 'separable', 'sequence'}, optional
-        If None, a single array is returned. For 'sequence', a tuple of smaller
-        footprints is returned. Applying this series of smaller footprints will
-        given an identical result to a single, larger footprint, but often with
-        better computational performance. See Notes for more details.
-
-    Returns
-    -------
-    footprint : cupy.ndarray
-        The footprint where elements of the neighborhood are 1 and 0 otherwise.
-        When `decomposition` is None, this is just a numpy.ndarray. Otherwise,
-        this will be a tuple whose length is equal to the number of unique
-        structuring elements to apply (see Notes for more detail)
-
-    Notes
-    -----
-    When `decomposition` is not None, each element of the `footprint`
-    tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a
-    footprint array and the number of iterations it is to be applied.
-
-    For binary morphology, using ``decomposition='sequence'``
-    was observed to give better performance, with the magnitude of the
-    performance increase rapidly increasing with footprint size. For grayscale
-    morphology with square footprints, it is recommended to use
-    ``decomposition=None`` since the internal SciPy functions that are called
-    already have a fast implementation based on separable 1D sliding windows.
-
-    The 'sequence' decomposition mode only supports odd valued `width`. If
-    `width` is even, the sequence used will be identical to the 'separable'
-    mode.
-    """
-    footprint = footprint_rectangle(
-        shape=(width, width, width), dtype=dtype, decomposition=decomposition
-    )
-    return footprint
-
-
 def octahedron(radius, dtype=cp.uint8, *, decomposition=None):
     """Generates a octahedron-shaped footprint.