Zero padding (1D/2D): add validation tests

Fix #171

Author: PierreRaybaut

cdl/algorithms/image.py

@@ -78,7 +78,7 @@ def zero_padding(
     image: np.ndarray,
     rows: int = 0,
     cols: int = 0,
-    position: Literal["bottom-right", "centered"] = "bottom-right",
+    position: Literal["bottom-right", "center"] = "bottom-right",
 ) -> np.ndarray:
     """
     Zero-pad a 2D image by adding rows and/or columns.
@@ -89,7 +89,7 @@ def zero_padding(
         cols: Number of columns to add in total (default: 0)
         position: Padding placement strategy:
             - "bottom-right": all padding is added to the bottom and right
-            - "centered": padding is split equally on top/bottom and left/right
+            - "center": padding is split equally on top/bottom and left/right
 
     Returns:
         The padded 2D image as a NumPy array.
@@ -104,7 +104,7 @@ def zero_padding(
 
     if position == "bottom-right":
         pad_width = ((0, rows), (0, cols))
-    elif position == "centered":
+    elif position == "center":
         pad_width = (
             (rows // 2, rows - rows // 2),
             (cols // 2, cols - cols // 2),

cdl/computation/image/__init__.py

@@ -1243,7 +1243,7 @@ def __init__(self, *args, **kwargs) -> None:
     def update_from_image(self, obj: ImageObj) -> None:
         """Update parameters from image"""
         self.__obj = obj
-        # self.choice_callback(None, self.strategy)
+        self.choice_callback(None, self.strategy)
 
     def choice_callback(self, item, value):
         """Callback to update padding values"""
@@ -1260,7 +1260,7 @@ def choice_callback(self, item, value):
     strategies = ("next_pow2", "multiple_of_64", "custom")
     _prop = gds.GetAttrProp("strategy")
     strategy = gds.ChoiceItem(
-        _("Padding strategy"), zip(strategies, strategies), default=strategies[0]
+        _("Padding strategy"), zip(strategies, strategies), default=strategies[-1]
     ).set_prop("display", store=_prop, callback=choice_callback)
 
     _func_prop = gds.FuncProp(_prop, lambda x: x == "custom")
@@ -1269,7 +1269,7 @@ def choice_callback(self, item, value):
         "display", active=_func_prop
     )
 
-    positions = ("bottom-right", "centered")
+    positions = ("bottom-right", "center")
     position = gds.ChoiceItem(
         _("Padding position"), zip(positions, positions), default=positions[0]
     )

cdl/computation/signal.py

@@ -907,7 +907,7 @@ def __init__(self, *args, **kwargs) -> None:
     def update_from_signal(self, obj: SignalObj) -> None:
         """Update parameters from signal"""
         self.__obj = obj
-        # self.choice_callback(None, self.strategy)
+        self.choice_callback(None, self.strategy)
 
     def choice_callback(self, item, value):
         """Callback for choice item"""
@@ -922,7 +922,7 @@ def choice_callback(self, item, value):
     strategies = ("next_pow2", "double", "triple", "custom")
     _prop = gds.GetAttrProp("strategy")
     strategy = gds.ChoiceItem(
-        _("Strategy"), zip(strategies, strategies), default=strategies[0]
+        _("Strategy"), zip(strategies, strategies), default=strategies[-1]
     ).set_prop("display", store=_prop, callback=choice_callback)
     _func_prop = gds.FuncProp(_prop, lambda x: x == "custom")
     n = gds.IntItem(

cdl/tests/features/images/fft2d_unit_test.py

@@ -14,6 +14,8 @@
 
 import cdl.algorithms.image as alg
 import cdl.computation.image as cpi
+import cdl.obj
+import cdl.param
 import cdl.tests.data as ctd
 from cdl.env import execenv
 from cdl.utils.tests import check_array_result, check_scalar_result
@@ -44,6 +46,74 @@ def test_image_fft_interactive():
         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 = ctd.create_checkerboard()
+    rows, cols = 2, 2
+    param = cdl.param.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 = cpi.compute_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 = "center"
+    ima3 = cpi.compute_zero_padding(ima1, param)
+    sh3 = ima3.data.shape
+    exp_sh3 = (sh1[0] + rows, sh1[1] + cols)
+    execenv.print("Validating zero padding for center 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 = cdl.obj.create_image("", np.zeros((200, 300)))
+    for strategy, (exp_rows, exp_cols) in (
+        ("next_pow2", (56, 212)),
+        ("multiple_of_64", (56, 20)),
+    ):
+        param = cdl.param.ZeroPadding2DParam.create(strategy=strategy)
+        param.update_from_image(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."""
@@ -105,6 +175,7 @@ def test_image_psd() -> None:
 
 if __name__ == "__main__":
     test_image_fft_interactive()
+    test_image_zero_padding()
     test_image_fft()
     test_image_magnitude_spectrum()
     test_image_phase_spectrum()

cdl/tests/features/signals/fft1d_unit_test.py

@@ -49,6 +49,48 @@ def test_signal_fft_interactive() -> None:
         view_curves([(t, y), (t2, y2)])
 
 
+@pytest.mark.validation
+def test_signal_zero_padding() -> None:
+    """1D FFT zero padding validation test."""
+    s1 = ctd.create_periodic_signal(cdl.obj.SignalTypes.COSINUS, freq=50.0, size=1000)
+
+    # Validate zero padding with custom length
+    param = cdl.param.ZeroPadding1DParam.create(n=250)
+    assert param.strategy == "custom", (
+        f"Wrong default strategy: {param.strategy} (expected 'custom')"
+    )
+    s2 = cps.compute_zero_padding(s1, param)
+    len1 = len(s1.y)
+    exp_len2 = len1 + param.n
+    execenv.print("Validating zero padding with custom length...", end=" ")
+    assert len(s2.y) == exp_len2, f"Wrong length: {len(s2.y)} (expected {exp_len2})"
+    assert np.all(s2.x[:len1] == s1.x[:len1]), "Altered X data in original signal area"
+    assert np.all(s2.y[:len1] == s1.y[:len1]), "Altered Y data in original signal area"
+    assert np.all(s2.y[len1:] == 0), "Non-zero data in zero-padded area"
+    execenv.print("OK")
+    step1 = s1.x[1] - s1.x[0]
+    check_array_result(
+        "Zero padding X data",
+        s2.x[len1:],
+        np.arange(
+            s1.x[len1 - 1] + step1, s1.x[len1 - 1] + step1 * (param.n + 1), step1
+        ),
+    )
+
+    # Validate zero padding with strategies other than custom length
+    for strategy, expected_length in (
+        ("next_pow2", 24),
+        ("double", 1000),
+        ("triple", 2000),
+    ):
+        param = cdl.param.ZeroPadding1DParam.create(strategy=strategy)
+        param.update_from_signal(s1)
+        assert param.n == expected_length, (
+            f"Wrong length for '{param.strategy}' strategy: {param.n}"
+            f" (expected {expected_length})"
+        )
+
+
 @pytest.mark.validation
 def test_signal_fft() -> None:
     """1D FFT validation test."""
@@ -158,6 +200,7 @@ def test_signal_psd() -> None:
 
 if __name__ == "__main__":
     test_signal_fft_interactive()
+    test_signal_zero_padding()
     test_signal_fft()
     test_signal_magnitude_spectrum()
     test_signal_phase_spectrum()