class_docstr: Some tests for local_minima are included as well.
class_docstr_tok: ["Some","tests","for","local_minima","are","included","as","well","."]
docstr: Specific tests for float type.
docstr_tok: ["Specific","tests","for","float","type","."]
code: def test_extrema_float(self):
      """Specific tests for float type."""
      # Copied from old unit test for local_maxma
      image = np.array(
          [
              [
                  0.10,
                  0.11,
                  0.13,
                  0.14,
                  0.14,
                  0.15,
                  0.14,
                  0.14,
                  0.13,
                  0.11,
              ],
              [
                  0.11,
                  0.13,
                  0.15,
                  0.16,
                  0.16,
                  0.16,
                  0.16,
                  0.16,
                  0.15,
                  0.13,
              ],
              [
                  0.13,
                  0.15,
                  0.40,
                  0.40,
                  0.18,
                  0.18,
                  0.18,
                  0.60,
                  0.60,
                  0.15,
              ],
              [
                  0.14,
                  0.16,
                  0.40,
                  0.40,
                  0.19,
                  0.19,
                  0.19,
                  0.60,
                  0.60,
                  0.16,
              ],
              [
                  0.14,
                  0.16,
                  0.18,
                  0.19,
                  0.19,
                  0.19,
                  0.19,
                  0.19,
                  0.18,
                  0.16,
              ],
              [
                  0.15,
                  0.182,
                  0.18,
                  0.19,
                  0.204,
                  0.20,
                  0.19,
                  0.19,
                  0.18,
                  0.16,
              ],
              [
                  0.14,
                  0.16,
                  0.18,
                  0.19,
                  0.19,
                  0.19,
                  0.19,
                  0.19,
                  0.18,
                  0.16,
              ],
              [
                  0.14,
                  0.16,
                  0.80,
                  0.80,
                  0.19,
                  0.19,
                  0.19,
                  1.0,
                  1.0,
                  0.16,
              ],
              [
                  0.13,
                  0.15,
                  0.80,
                  0.80,
                  0.18,
                  0.18,
                  0.18,
                  1.0,
                  1.0,
                  0.15,
              ],
              [
                  0.11,
                  0.13,
                  0.15,
                  0.16,
                  0.16,
                  0.16,
                  0.16,
                  0.16,
                  0.15,
                  0.13,
              ],
          ],
          dtype=np.float32,
      )
      inverted_image = 1.0 - image
      expected_result = np.array(
          [
              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 0, 0, 0, 1, 1, 0],
              [0, 0, 1, 1, 0, 0, 0, 1, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              [0, 1, 0, 0, 1, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 0, 0, 0, 1, 1, 0],
              [0, 0, 1, 1, 0, 0, 0, 1, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
          ],
          dtype=bool,
      )
  
      # Test for local maxima with automatic step calculation
      result = extrema.local_maxima(image)
      assert result.dtype == bool
      assert_equal(result, expected_result)
  
      # Test for local minima with automatic step calculation
      result = extrema.local_minima(inverted_image)
      assert result.dtype == bool
      assert_equal(result, expected_result)
  
imports: import math
  import unittest
  import numpy
  from numpy.testing import assert_equal
  from pytest import raises, warns
  from skimage._shared.testing import expected_warnings
  from skimage.morphology import extrema
label_desc: Use image node_id 10 for calling the TestLocalMaxima obj's underlying member method code with example usage: obj.test_extrema_float() without return types