This function iterates over all objects (connected pixels that are True)
inside an image and removes neighboring objects until all remaining ones
are at least a minimal euclidean distance from each other.

_extrema_cy.pyx was cythonized twice for now reason.

Simplify construction of indices, use consistent name for structuring
element (selem), some reformatting and improve documentation.

This trick significantly improves the performance by reducing the number
of points inside the KDTree whose neighborhood needs to be evaluated
for objects that are to close. The greater the checked objects size to
surface ratio, the greater the improvement.

numpy.bincount seems to cast its input to dtype('intp') according to
the rule safe. Therefore giving a dtype such as uint32 or int64 that
can hold a larger number fails on 32-bit platforms.

With recent changes the evalutation order of objects changed.

The latter was added in NumPy 1.15 which is not yet a minimal
requirement for scikit-image.

The old implementation would raise a ValueError if a dimension length
given in `image_shape` was smaller than in `selem`. This precluded
operations on images e.g. with the shape (2, 100).

This allows the user to control how the distance between objects/samples
is calculated (e.g. Euclidean, Manhatten, Chebyshev).

return_sorted was added in SciPy 1.2 and is not yet supported by
scikit-images minimal required version.

"close" can have multiple meanings especially in the context of
morphological operations (closing). So the synonym "near" should have
less potential for confusion.

Resolve Conflicts in:
doc/release/release_dev.rst
skimage/morphology/_flood_fill.py
skimage/morphology/_util.py
skimage/morphology/extrema.py

This example demonstrates the usage of remove_small_objects and
remove_near_objects.

Already declared, so no need to duplicate it here.

and rename selem to footprint for a more consistent API.

ravel is replaced with reshape(-1) as recommended by NumPy's doc.

It's easier to seperate the tests for this functions from the other
ones this way.

_offsets_to_raveled_neighbors is now a just a wrapper for
_raveled_offsets_and_distances, so replace it.

Special handling of an empty `image` is no longer necessary as both
_raveled_offsets_and_distances and cKDTree support arrays with size 0.

`out` must be C-contiguous which allows for efficient indexing in the
underlying Cython code. This might raise an error if out is supplied by
the user so document it with a test.

It seems that special logic for bool-type arrays is no longer necessary
as the appropriate PR [1] was merged.

[1] cython/cython#2676

# Conflicts:
#	benchmarks/benchmark_morphology.py
#	skimage/morphology/__init__.py
#	skimage/morphology/misc.py
#	skimage/morphology/setup.py

to make CI linter happy.

and fix import path of _shared.fused_numerics. Of course wouldn't
compile otherwise.

The warning was found by the CI (linux-cp3.9-pre) for NumPy v1.24.1:

DeprecationWarning: NumPy will stop allowing conversion of out-of-bound
Python integers to integer arrays.  The conversion of -1 to uint32 will
fail in the future.

The objects don't have to be -1, just any number != 0.

Maybe missed during merging?

This overhauls the API of remove_near_objects. Instead of labeling the
input itself, the function already expects a labeled image. Sorting an
index into this label_image by label ID first, and by priority second,
makes it easy to find other indices belonging to the same object because
they are contiguous in the resulting index. This makes it possible to
entirely omit the parameters connectivity and footprint (for now).

`priority` now is expected to assign a priority to each object and no
longer gives a priority for each pixel.

Test and benchmarks were updated accordingly.

Also sadly the optimization isn't working as expected. See
test_objects_with_inside.

requires an additional copy but still, good to support.

Even with the additional cost of separating bounday and inner samples
of objects, this improves the performance significantly!

and also add a random test that uses CKDTree.sparse_distance_matrix to
manually check distance between remaining objects.

or corner_peaks.

for unity spacing and if p-norm is 1 or 2. Also refactor code structure
a little bit.