sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/image/exposure_unit_test.py

@@ -0,0 +1,223 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for exposure computation functions.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from skimage import exposure
+
+import sigima.enums
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+from sigima.tests.data import get_test_image
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.validation
+def test_adjust_gamma() -> None:
+    """Validation test for the image gamma adjustment processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    for gamma, gain in ((0.5, 1.0), (1.0, 2.0), (1.5, 0.5)):
+        p = sigima.params.AdjustGammaParam.create(gamma=gamma, gain=gain)
+        dst = sigima.proc.image.adjust_gamma(src, p)
+        exp = exposure.adjust_gamma(src.data, gamma=gamma, gain=gain)
+        check_array_result(f"AdjustGamma[gamma={gamma},gain={gain}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_adjust_log() -> None:
+    """Validation test for the image logarithmic adjustment processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    for gain, inv in ((1.0, False), (2.0, True)):
+        p = sigima.params.AdjustLogParam.create(gain=gain, inv=inv)
+        dst = sigima.proc.image.adjust_log(src, p)
+        exp = exposure.adjust_log(src.data, gain=gain, inv=inv)
+        check_array_result(f"AdjustLog[gain={gain},inv={inv}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_adjust_sigmoid() -> None:
+    """Validation test for the image sigmoid adjustment processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    for cutoff, gain, inv in ((0.5, 1.0, False), (0.25, 2.0, True)):
+        p = sigima.params.AdjustSigmoidParam.create(cutoff=cutoff, gain=gain, inv=inv)
+        dst = sigima.proc.image.adjust_sigmoid(src, p)
+        exp = exposure.adjust_sigmoid(src.data, cutoff=cutoff, gain=gain, inv=inv)
+        check_array_result(
+            f"AdjustSigmoid[cutoff={cutoff},gain={gain},inv={inv}]", dst.data, exp
+        )
+
+
+@pytest.mark.validation
+def test_rescale_intensity() -> None:
+    """Validation test for the image intensity rescaling processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    p = sigima.params.RescaleIntensityParam.create(in_range="dtype", out_range="image")
+    dst = sigima.proc.image.rescale_intensity(src, p)
+    exp = exposure.rescale_intensity(
+        src.data, in_range=p.in_range, out_range=p.out_range
+    )
+    check_array_result("RescaleIntensity", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_equalize_hist() -> None:
+    """Validation test for the image histogram equalization processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    for nbins in (256, 512):
+        p = sigima.params.EqualizeHistParam.create(nbins=nbins)
+        dst = sigima.proc.image.equalize_hist(src, p)
+        exp = exposure.equalize_hist(src.data, nbins=nbins)
+        check_array_result(f"EqualizeHist[nbins={nbins}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_equalize_adapthist() -> None:
+    """Validation test for the image adaptive histogram equalization processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    for clip_limit in (0.01, 0.1):
+        p = sigima.params.EqualizeAdaptHistParam.create(clip_limit=clip_limit)
+        dst = sigima.proc.image.equalize_adapthist(src, p)
+        exp = exposure.equalize_adapthist(src.data, clip_limit=clip_limit)
+        check_array_result(f"AdaptiveHist[clip_limit={clip_limit}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_flatfield() -> None:
+    """Validation test for the image flat-field correction processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src1 = get_test_image("flower.npy")  # Raw data
+    src2 = get_test_image("flower.npy")  # Flat field data (using same image as base)
+
+    # Modify flat field data to create realistic flat field variation
+    src2.data = src2.data.astype(float)
+    src2.data = src2.data / np.max(src2.data) * 100 + 50  # Scale to reasonable range
+
+    for threshold in (0.0, 10.0, 30.0):
+        p = sigima.params.FlatFieldParam.create(threshold=threshold)
+        dst = sigima.proc.image.flatfield(src1, src2, p)
+
+        # Compute expected result using the same algorithm as in sigima.tools.image
+        dtemp = np.array(src1.data, dtype=float, copy=True) * np.nanmean(src2.data)
+        dunif = np.array(src2.data, dtype=float, copy=True)
+        dunif[dunif == 0] = 1.0
+        dcorr_all = np.array(dtemp / dunif, dtype=src1.data.dtype)
+        exp = np.array(src1.data, copy=True)
+        exp[src1.data > threshold] = dcorr_all[src1.data > threshold]
+
+        check_array_result(f"FlatField[threshold={threshold}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_image_normalize() -> None:
+    """Validation test for the image normalization processing."""
+    src = get_test_image("flower.npy")
+    src.data = np.array(src.data, dtype=float)
+    src.data[20:30, 20:30] = np.nan  # Adding NaN values to the image
+    p = sigima.params.NormalizeParam()
+
+    # Given the fact that the normalization methods implementations are
+    # straightforward, we do not need to compare arrays with each other,
+    # we simply need to check if some properties are satisfied.
+    for method in sigima.enums.NormalizationMethod:
+        p.method = method
+        dst = sigima.proc.image.normalize(src, p)
+        title = f"Normalize[method='{p.method}']"
+        exp_min, exp_max = None, None
+        if p.method == sigima.enums.NormalizationMethod.MAXIMUM:
+            exp_min, exp_max = np.nanmin(src.data) / np.nanmax(src.data), 1.0
+        elif p.method == sigima.enums.NormalizationMethod.AMPLITUDE:
+            exp_min, exp_max = 0.0, 1.0
+        elif p.method == sigima.enums.NormalizationMethod.AREA:
+            area = np.nansum(src.data)
+            exp_min, exp_max = np.nanmin(src.data) / area, np.nanmax(src.data) / area
+        elif p.method == sigima.enums.NormalizationMethod.ENERGY:
+            energy = np.sqrt(np.nansum(np.abs(src.data) ** 2))
+            exp_min, exp_max = (
+                np.nanmin(src.data) / energy,
+                np.nanmax(src.data) / energy,
+            )
+        elif p.method == sigima.enums.NormalizationMethod.RMS:
+            rms = np.sqrt(np.nanmean(np.abs(src.data) ** 2))
+            exp_min, exp_max = np.nanmin(src.data) / rms, np.nanmax(src.data) / rms
+        check_scalar_result(f"{title}|min", np.nanmin(dst.data), exp_min)
+        check_scalar_result(f"{title}|max", np.nanmax(dst.data), exp_max)
+
+
+@pytest.mark.validation
+def test_image_clip() -> None:
+    """Validation test for the image clipping processing."""
+    src = get_test_image("flower.npy")
+    p = sigima.params.ClipParam()
+
+    for lower, upper in ((float("-inf"), float("inf")), (50, 100)):
+        p.lower, p.upper = lower, upper
+        dst = sigima.proc.image.clip(src, p)
+        exp = np.clip(src.data, p.lower, p.upper)
+        check_array_result(f"Clip[{lower},{upper}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_image_histogram() -> None:
+    """Validation test for the image histogram computation function."""
+    src = get_test_image("flower.npy")
+    for bins in (128, 256, 512):
+        for lower, upper in ((None, None), (50.0, 200.0)):
+            p = sigima.params.HistogramParam.create(bins=bins, lower=lower, upper=upper)
+            dst = sigima.proc.image.histogram(src, p)
+
+            # Get the actual data used for histogram computation
+            data = src.get_masked_view().compressed()
+
+            # Determine the range for numpy.histogram
+            hist_range = (p.lower, p.upper)
+            if p.lower is None:
+                hist_range = (np.min(data), hist_range[1])
+            if p.upper is None:
+                hist_range = (hist_range[0], np.max(data))
+
+            # Compute expected histogram using numpy.histogram
+            exp_y, bin_edges = np.histogram(data, bins=p.bins, range=hist_range)
+            exp_x = (bin_edges[:-1] + bin_edges[1:]) / 2
+
+            title = f"Histogram[bins={bins},lower={lower},upper={upper}]"
+            check_array_result(f"{title}|x", dst.x, exp_x)
+            check_array_result(f"{title}|y", dst.y, np.array(exp_y, dtype=float))
+
+
+@pytest.mark.validation
+def test_image_offset_correction() -> None:
+    """Validation test for the image offset correction processing."""
+    src = get_test_image("flower.npy")
+    # Defining the ROI that will be used to estimate the offset
+    p = sigima.objects.ROI2DParam.create(x0=0, y0=0, dx=50, dy=20)
+    dst = sigima.proc.image.offset_correction(src, p)
+    ix0, iy0 = int(p.x0), int(p.y0)
+    ix1, iy1 = int(p.x0 + p.dx), int(p.y0 + p.dy)
+    exp = src.data - np.mean(src.data[iy0:iy1, ix0:ix1])
+    check_array_result("OffsetCorrection", dst.data, exp)
+
+
+if __name__ == "__main__":
+    test_adjust_gamma()
+    test_adjust_log()
+    test_adjust_sigmoid()
+    test_rescale_intensity()
+    test_equalize_hist()
+    test_equalize_adapthist()
+    test_flatfield()
+    test_image_normalize()
+    test_image_clip()
+    test_image_histogram()
+    test_image_offset_correction()

sigima/tests/image/fft2d_unit_test.py

@@ -0,0 +1,189 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image FFT unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+import sigima.tests.data
+import sigima.tools.image
+from sigima.tests import guiutils
+from sigima.tests.env import execenv
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.gui
+def test_image_fft_interactive():
+    """2D FFT interactive test."""
+    with guiutils.lazy_qt_app_context(force=True):
+        from sigima.tests import vistools  # pylint: disable=import-outside-toplevel
+
+        # Create a 2D ring image
+        execenv.print("Generating 2D ring image...", end=" ")
+        data = sigima.tests.data.create_ring_image().data
+        execenv.print("OK")
+
+        # FFT
+        execenv.print("Computing FFT of image...", end=" ")
+        f = sigima.tools.image.fft2d(data)
+        data2 = sigima.tools.image.ifft2d(f)
+        execenv.print("OK")
+        execenv.print("Comparing original and FFT/iFFT images...", end=" ")
+        check_array_result(
+            "Image FFT/iFFT", np.array(data2.real, dtype=data.dtype), data, rtol=1e-3
+        )
+        execenv.print("OK")
+
+        images = [data, f.real, f.imag, np.abs(f), data2.real, data2.imag]
+        titles = ["Original", "Re(FFT)", "Im(FFT)", "Abs(FFT)", "Re(iFFT)", "Im(iFFT)"]
+        vistools.view_images_side_by_side(images, titles, rows=2, title="2D FFT/iFFT")
+
+
+@pytest.mark.validation
+def test_image_zero_padding() -> None:
+    """2D FFT zero padding validation test."""
+    ima1 = sigima.tests.data.create_checkerboard()
+    rows, cols = 2, 2
+    param = sigima.params.ZeroPadding2DParam.create(rows=rows, cols=cols)
+    assert param.strategy == "custom", (
+        f"Wrong default strategy: {param.strategy} (expected 'custom')"
+    )
+
+    # Validate the zero padding with bottom-right position
+    param.position = "bottom-right"
+    ima2 = sigima.proc.image.zero_padding(ima1, param)
+    sh1, sh2 = ima1.data.shape, ima2.data.shape
+    exp_sh2 = (sh1[0] + rows, sh1[1] + cols)
+    execenv.print("Validating zero padding for bottom-right position...", end=" ")
+    assert sh2 == exp_sh2, f"Wrong shape: {sh2} (expected {exp_sh2})"
+    assert np.all(ima2.data[0 : sh1[0], 0 : sh1[1]] == ima1.data), (
+        "Altered data in original image area"
+    )
+    assert np.all(ima2.data[sh1[0] : sh2[0], sh1[1] : sh2[1]] == 0), (
+        "Altered data in padded area"
+    )
+    execenv.print("OK")
+
+    # Validate the zero padding with center position
+    param.position = "around"
+    ima3 = sigima.proc.image.zero_padding(ima1, param)
+    sh3 = ima3.data.shape
+    exp_sh3 = (sh1[0] + rows, sh1[1] + cols)
+    execenv.print("Validating zero padding for around position...", end=" ")
+    assert sh3 == exp_sh3, f"Wrong shape: {sh3} (expected {exp_sh3})"
+    assert np.all(
+        ima3.data[rows // 2 : sh1[0] + rows // 2, cols // 2 : sh1[1] + cols // 2]
+        == ima1.data
+    ), "Altered data in original image area"
+    assert np.all(ima3.data[0 : rows // 2, :] == 0), "Altered data in padded area (top)"
+    assert np.all(ima3.data[sh1[0] + rows // 2 :, :] == 0), (
+        "Altered data in padded area (bottom)"
+    )
+    assert np.all(ima3.data[:, 0 : cols // 2] == 0), (
+        "Altered data in padded area (left)"
+    )
+    assert np.all(ima3.data[:, sh1[1] + cols // 2 :] == 0), (
+        "Altered data in padded area (right)"
+    )
+    execenv.print("OK")
+
+    # Validate zero padding with strategies other than custom size
+    # Image size is (200, 300) and the next power of 2 is (256, 512)
+    # The multiple of 64 is (256, 320)
+    ima4 = sigima.objects.create_image("", np.zeros((200, 300)))
+    for strategy, (exp_rows, exp_cols) in (
+        ("next_pow2", (56, 212)),
+        ("multiple_of_64", (56, 20)),
+    ):
+        param = sigima.params.ZeroPadding2DParam.create(strategy=strategy)
+        param.update_from_obj(ima4)
+        assert param.rows == exp_rows, (
+            f"Wrong row number for '{param.strategy}' strategy: {param.rows}"
+            f" (expected {exp_rows})"
+        )
+        assert param.cols == exp_cols, (
+            f"Wrong column number for '{param.strategy}' strategy: {param.cols}"
+            f" (expected {exp_cols})"
+        )
+
+
+@pytest.mark.validation
+def test_image_fft() -> None:
+    """2D FFT validation test."""
+    ima1 = sigima.tests.data.create_checkerboard()
+    fft = sigima.proc.image.fft(ima1)
+    ifft = sigima.proc.image.ifft(fft)
+
+    # Check that the inverse FFT reconstructs the original image
+    check_array_result("Checkerboard image FFT/iFFT", ifft.data.real, ima1.data)
+
+    # Parseval's Theorem Validation
+    original_energy = np.sum(np.abs(ima1.data) ** 2)
+    transformed_energy = np.sum(np.abs(fft.data) ** 2) / (ima1.data.size)
+    check_scalar_result("Parseval's Theorem", transformed_energy, original_energy)
+
+
+@pytest.mark.skip(reason="Already covered by the `test_image_fft` test.")
+@pytest.mark.validation
+def test_image_ifft() -> None:
+    """2D iFFT validation test."""
+    # This is just a way of marking the iFFT test as a validation test because it is
+    # already covered by the FFT test above (there is no need to repeat the same test).
+
+
+@pytest.mark.validation
+def test_image_magnitude_spectrum() -> None:
+    """2D magnitude spectrum validation test."""
+    ima1 = sigima.tests.data.create_checkerboard()
+    fft = sigima.proc.image.fft(ima1)
+    param = sigima.params.SpectrumParam()
+    for decibel in (True, False):
+        param.decibel = decibel
+        mag = sigima.proc.image.magnitude_spectrum(ima1, param)
+
+    # Check that the magnitude spectrum is correct
+    exp = np.abs(fft.data)
+    check_array_result("Checkerboard image FFT magnitude spectrum", mag.data, exp)
+
+
+@pytest.mark.validation
+def test_image_phase_spectrum() -> None:
+    """2D phase spectrum validation test."""
+    ima1 = sigima.tests.data.create_checkerboard()
+    fft = sigima.proc.image.fft(ima1)
+    phase = sigima.proc.image.phase_spectrum(ima1)
+
+    # Check that the phase spectrum is correct
+    exp = np.rad2deg(np.angle(fft.data))
+    check_array_result("Checkerboard image FFT phase spectrum", phase.data, exp)
+
+
+@pytest.mark.validation
+def test_image_psd() -> None:
+    """2D Power Spectral Density validation test."""
+    ima1 = sigima.tests.data.create_checkerboard()
+    param = sigima.params.SpectrumParam()
+    for decibel in (True, False):
+        param.decibel = decibel
+        psd = sigima.proc.image.psd(ima1, param)
+
+    # Check that the PSD is correct
+    exp = np.abs(sigima.proc.image.fft(ima1).data) ** 2
+    check_array_result("Checkerboard image PSD", psd.data, exp)
+
+
+if __name__ == "__main__":
+    test_image_fft_interactive()
+    test_image_zero_padding()
+    test_image_fft()
+    test_image_magnitude_spectrum()
+    test_image_phase_spectrum()
+    test_image_psd()

sigima/tests/image/filtering_unit_test.py

@@ -0,0 +1,166 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for image filtering functions.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import scipy.ndimage as spi
+import scipy.signal as sps
+from skimage import filters
+
+import sigima.enums
+import sigima.params
+import sigima.proc.image
+import sigima.tools.image
+from sigima.objects import ImageObj
+from sigima.objects.image import create_image
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_image
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.validation
+def test_image_gaussian_filter() -> None:
+    """Validation test for the image Gaussian filter processing."""
+    src = get_test_image("flower.npy")
+    for sigma in (10.0, 50.0):
+        p = sigima.params.GaussianParam.create(sigma=sigma)
+        dst = sigima.proc.image.gaussian_filter(src, p)
+        exp = spi.gaussian_filter(src.data, sigma=sigma)
+        check_array_result(f"GaussianFilter[sigma={sigma}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_image_moving_average() -> None:
+    """Validation test for the image moving average processing."""
+    src = get_test_image("flower.npy")
+    p = sigima.params.MovingAverageParam.create(n=30)
+    for mode in sigima.enums.FilterMode:
+        p.mode = mode
+        dst = sigima.proc.image.moving_average(src, p)
+        exp = spi.uniform_filter(src.data, size=p.n, mode=mode.value)
+        check_array_result(f"MovingAvg[n={p.n},mode={p.mode}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_image_moving_median() -> None:
+    """Validation test for the image moving median processing."""
+    src = get_test_image("flower.npy")
+    p = sigima.params.MovingMedianParam.create(n=5)
+    for mode in sigima.enums.FilterMode:
+        p.mode = mode
+        dst = sigima.proc.image.moving_median(src, p)
+        exp = spi.median_filter(src.data, size=p.n, mode=mode.value)
+        check_array_result(f"MovingMed[n={p.n},mode={p.mode}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_image_wiener() -> None:
+    """Validation test for the image Wiener filter processing."""
+    src = get_test_image("flower.npy")
+    dst = sigima.proc.image.wiener(src)
+    exp = sps.wiener(src.data)
+    check_array_result("Wiener", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_butterworth() -> None:
+    """Validation test for the image Butterworth filter processing."""
+    src = get_test_image("flower.npy")
+    p = sigima.params.ButterworthParam.create(order=2, cut_off=0.5, high_pass=False)
+    dst = sigima.proc.image.butterworth(src, p)
+    exp = filters.butterworth(src.data, p.cut_off, p.high_pass, p.order)
+    check_array_result(
+        f"Butterworth[order={p.order},cut_off={p.cut_off},high_pass={p.high_pass}]",
+        dst.data,
+        exp,
+    )
+
+
+def build_clean_noisy_images(
+    shape: tuple[int, int] = (64, 64), noise_level: float = 0.4, freq: float = 0.05
+) -> tuple[ImageObj, ImageObj]:
+    """Generate a test image with a low-frequency signal and high-frequency noise.
+
+    Args:
+        shape: Shape of the image (height, width).
+        noise_level: Standard deviation of the Gaussian noise.
+        freq: Frequency of the low-frequency signal.
+
+    Returns:
+        Tuple of (clean, noisy) where:
+        - clean: The low-frequency component of the image.
+        - noisy: The noisy image with added Gaussian noise.
+    """
+    # Low frequency signal: sinusoid with frequency in px^-1
+    x = np.arange(shape[1])
+    y = np.arange(shape[0])
+    x_matrice, y_matrice = np.meshgrid(x, y)
+    low_freq = 0.5 * (np.sin(2 * np.pi * freq * x_matrice)) + 0.5 * (
+        np.sin(2 * np.pi * freq * y_matrice)
+    )
+
+    # High frequency noise
+    rng = np.random.default_rng(seed=0)
+    high_freq_noise = noise_level * rng.standard_normal(size=shape)
+
+    # Sum of the two components
+    img = low_freq + high_freq_noise
+    return create_image("clean", low_freq), create_image("noisy", img)
+
+
+@pytest.mark.validation
+def test_gaussian_freq_filter() -> None:
+    """Validation test for :py:func:`sigima.tools.image.gaussian_freq_filter`."""
+    clean, noisy = build_clean_noisy_images(freq=0.05)
+    param = sigima.proc.image.GaussianFreqFilterParam.create(f0=0.05, sigma=0.05)
+    filt = sigima.proc.image.gaussian_freq_filter(noisy, param)
+    clean_area = clean.data[10:-10, 10:-10]
+    guiutils.view_images_side_by_side_if_gui(
+        [clean, noisy, filt], titles=["Clean", "Noisy", "Filtered"]
+    )
+    mean_noise = float(np.mean(np.abs(clean_area - filt.data[10:-10, 10:-10])))
+    check_scalar_result(
+        "gaussian_freq_filter noise reduction", mean_noise, 0.0, atol=0.1
+    )
+
+
+def test_gaussian_freq_filter_constant_image() -> None:
+    """Edge case: filtering a constant image must preserve the constant value
+    (DC component)."""
+    img_const = np.full((64, 64), fill_value=7.42)
+    zout = sigima.tools.image.gaussian_freq_filter(img_const, f0=0.0, sigma=0.05)
+    # Ignore borders
+    center = zout[10:-10, 10:-10]
+    # Assert that all values are (almost) equal to the original constant
+    assert np.allclose(center, 7.42, atol=1e-10), "Filtering constant image failed"
+
+
+def test_gaussian_freq_filter_symmetry() -> None:
+    """Test: filtering a symmetric image yields a symmetric result."""
+    # Create a symmetric image (e.g., a centered 2D Gaussian)
+    x = np.linspace(-1, 1, 64)
+    y = np.linspace(-1, 1, 64)
+    xv, yv = np.meshgrid(x, y)
+    img = np.exp(-(xv**2 + yv**2) / 0.1)
+
+    zout = sigima.tools.image.gaussian_freq_filter(img, f0=0.05, sigma=0.02)
+    # Symmetry check: image must be (almost) symmetric along both axes
+    assert np.allclose(zout, zout[::-1, :], atol=1e-10), "Vertical symmetry lost"
+    assert np.allclose(zout, zout[:, ::-1], atol=1e-10), "Horizontal symmetry lost"
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_image_gaussian_filter()
+    test_image_moving_average()
+    test_image_moving_median()
+    test_image_wiener()
+    test_butterworth()
+    test_gaussian_freq_filter()
+    test_gaussian_freq_filter_constant_image()
+    test_gaussian_freq_filter_symmetry()