add a few more nodes

tests/node_tests/arc_revolve.py

@@ -0,0 +1,55 @@
+import numpy as np
+from tests.node_tests._shared import make_field
+
+
+def test_arc_revolve_horizontal():
+    from backend.nodes.arc_revolve import ArcRevolve
+
+    node = ArcRevolve()
+    rng = np.random.default_rng(42)
+    x = np.linspace(0, 1, 64)
+    bow = 10.0 * x ** 2
+    data = bow[None, :] + rng.standard_normal((64, 64)) * 0.01
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=40, direction="horizontal")
+    assert leveled.data.shape == field.data.shape
+    assert bg.data.shape == field.data.shape
+    assert np.allclose(leveled.data + bg.data, data)
+
+
+def test_arc_revolve_vertical():
+    from backend.nodes.arc_revolve import ArcRevolve
+
+    node = ArcRevolve()
+    y = np.linspace(0, 1, 64)
+    data = (5.0 * y ** 2)[:, None] * np.ones((1, 64))
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=40, direction="vertical")
+    assert np.allclose(leveled.data + bg.data, data)
+
+
+def test_arc_revolve_both():
+    from backend.nodes.arc_revolve import ArcRevolve
+
+    node = ArcRevolve()
+    y, x = np.mgrid[:32, :32] / 32.0
+    data = 5.0 * x ** 2 + 3.0 * y ** 2
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=30, direction="both")
+    assert leveled.data.shape == data.shape
+    assert bg.data.shape == data.shape
+
+
+def test_arc_revolve_flat_passthrough():
+    from backend.nodes.arc_revolve import ArcRevolve
+
+    node = ArcRevolve()
+    data = np.ones((32, 32)) * 5.0
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=20, direction="horizontal")
+    assert leveled.data.std() < 1e-10
+    assert np.allclose(leveled.data + bg.data, data)

tests/node_tests/level_rotate.py

@@ -0,0 +1,37 @@
+import numpy as np
+from tests.node_tests._shared import make_field
+
+
+def test_level_rotate_removes_tilt():
+    from backend.nodes.level_rotate import LevelRotate
+
+    node = LevelRotate()
+    y, x = np.mgrid[:64, :64].astype(np.float64)
+    data = 2.0 * x + 3.0 * y
+    field = make_field(data=data)
+
+    (result,) = node.process(field)
+    assert result.data.shape == data.shape
+    assert result.data.std() < data.std() * 0.25
+
+
+def test_level_rotate_preserves_shape():
+    from backend.nodes.level_rotate import LevelRotate
+
+    node = LevelRotate()
+    data = np.random.default_rng(42).standard_normal((48, 48))
+    field = make_field(data=data)
+
+    (result,) = node.process(field)
+    assert result.data.shape == (48, 48)
+
+
+def test_level_rotate_flat_noop():
+    from backend.nodes.level_rotate import LevelRotate
+
+    node = LevelRotate()
+    data = np.ones((32, 32)) * 7.0
+    field = make_field(data=data)
+
+    (result,) = node.process(field)
+    assert np.allclose(result.data, 7.0, atol=1e-6)

tests/node_tests/sphere_revolve.py

@@ -0,0 +1,41 @@
+import numpy as np
+from tests.node_tests._shared import make_field
+
+
+def test_sphere_revolve_basic():
+    from backend.nodes.sphere_revolve import SphereRevolve
+
+    node = SphereRevolve()
+    y, x = np.mgrid[:64, :64] / 64.0
+    data = 10.0 * (x ** 2 + y ** 2)
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=30)
+    assert leveled.data.shape == data.shape
+    assert bg.data.shape == data.shape
+    assert np.allclose(leveled.data + bg.data, data)
+
+
+def test_sphere_revolve_flat():
+    from backend.nodes.sphere_revolve import SphereRevolve
+
+    node = SphereRevolve()
+    data = np.ones((32, 32)) * 3.0
+    field = make_field(data=data)
+
+    leveled, bg = node.process(field, radius=20)
+    assert leveled.data.std() < 1e-10
+    assert np.allclose(leveled.data + bg.data, data)
+
+
+def test_sphere_revolve_outputs_two_fields():
+    from backend.nodes.sphere_revolve import SphereRevolve
+
+    node = SphereRevolve()
+    data = np.random.default_rng(7).standard_normal((32, 32))
+    field = make_field(data=data)
+
+    result = node.process(field, radius=15)
+    assert len(result) == 2
+    leveled, bg = result
+    assert np.allclose(leveled.data + bg.data, data)

tests/node_tests/unrotate.py

@@ -0,0 +1,50 @@
+import numpy as np
+from tests.node_tests._shared import make_field
+
+
+def test_unrotate_preserves_shape():
+    from backend.nodes.unrotate import Unrotate
+
+    node = Unrotate()
+    data = np.random.default_rng(42).standard_normal((64, 64))
+    field = make_field(data=data)
+
+    (result,) = node.process(field, symmetry="4-fold")
+    assert result.data.shape == (64, 64)
+
+
+def test_unrotate_small_angle():
+    from backend.nodes.unrotate import Unrotate, _slope_angle_histogram, _find_dominant_angle
+
+    y, x = np.mgrid[:128, :128].astype(np.float64)
+    angle_deg = 3.0
+    angle_rad = np.radians(angle_deg)
+    data = np.sin(2 * np.pi * (x * np.cos(angle_rad) + y * np.sin(angle_rad)) / 20.0)
+
+    hist = _slope_angle_histogram(data)
+    correction = _find_dominant_angle(hist, 4)
+    assert abs(np.degrees(correction)) < 10.0
+
+
+def test_unrotate_no_rotation_passthrough():
+    from backend.nodes.unrotate import Unrotate
+
+    node = Unrotate()
+    y, x = np.mgrid[:64, :64].astype(np.float64)
+    data = np.sin(2 * np.pi * x / 16.0)
+    field = make_field(data=data)
+
+    (result,) = node.process(field, symmetry="4-fold")
+    assert np.allclose(result.data, data, atol=0.1)
+
+
+def test_unrotate_symmetry_options():
+    from backend.nodes.unrotate import Unrotate
+
+    node = Unrotate()
+    data = np.random.default_rng(99).standard_normal((64, 64))
+    field = make_field(data=data)
+
+    for sym in ["2-fold", "3-fold", "4-fold", "6-fold"]:
+        (result,) = node.process(field, symmetry=sym)
+        assert result.data.shape == (64, 64)

tests/node_tests/zero_value.py

@@ -0,0 +1,46 @@
+import numpy as np
+from tests.node_tests._shared import make_field
+
+
+def test_zero_mean():
+    from backend.nodes.zero_value import ZeroMean
+
+    node = ZeroMean()
+    data = np.random.default_rng(42).standard_normal((64, 64)) + 100.0
+    field = make_field(data=data)
+    (result,) = node.process(field)
+    assert result.data.shape == field.data.shape
+    assert abs(result.data.mean()) < 1e-10
+
+
+def test_zero_mean_preserves_variation():
+    from backend.nodes.zero_value import ZeroMean
+
+    node = ZeroMean()
+    data = np.random.default_rng(7).standard_normal((32, 32)) + 50.0
+    field = make_field(data=data)
+    (result,) = node.process(field)
+    assert np.allclose(result.data - result.data.mean(), data - data.mean())
+
+
+def test_zero_maximum():
+    from backend.nodes.zero_value import ZeroMaximum
+
+    node = ZeroMaximum()
+    data = np.random.default_rng(42).standard_normal((64, 64)) + 100.0
+    field = make_field(data=data)
+    (result,) = node.process(field)
+    assert result.data.shape == field.data.shape
+    assert abs(result.data.max()) < 1e-10
+    assert result.data.min() < 0
+
+
+def test_zero_maximum_preserves_differences():
+    from backend.nodes.zero_value import ZeroMaximum
+
+    node = ZeroMaximum()
+    data = np.array([[1.0, 3.0], [2.0, 5.0]])
+    field = make_field(data=data)
+    (result,) = node.process(field)
+    expected = data - 5.0
+    assert np.allclose(result.data, expected)