(building) Support more modes of creating the foundation (#10)

Author: ahyangyi

agrf/graphics/cv/foundation.py

@@ -2,137 +2,93 @@
 import numpy as np
 from .. import LayeredImage
 
+THIS_FILE = grf.PythonFile(__file__)
 
-def make_foundation_subimage(img: LayeredImage, scale, part, style, cut_inside, zshift, solid) -> LayeredImage:
-    if img.alpha is not None:
-        r = np.arange(img.h)[:, np.newaxis] + img.yofs + 0.5 + zshift * scale
-        c = np.arange(img.w)[np.newaxis] + img.xofs - scale + 0.5
-        if style == "ground":
-            if cut_inside:
-                raise NotImplementedError()
-            else:
-                alphamask = (
-                    (r * 2 - c <= 48 * scale)
-                    * (r * 2 + c <= 48 * scale)
-                    * (r * 2 + c >= -16 * scale)
-                    * (r * 2 - c >= -16 * scale)
-                )
-        elif style == "simple":
-            if part == 0:
-                alphamask = (r * 4 - c * 3 <= 128 * scale) * (c <= 0)
-                if cut_inside:
-                    alphamask *= r * 2 - c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 2 + c >= -16 * scale
-            elif part == 1:
-                alphamask = (r * 2 - c <= 64 * scale) * (c <= 0)
-                if cut_inside:
-                    alphamask *= r * 2 - c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 4 + c * 3 >= -32 * scale
-            elif part == 2:
-                alphamask = (r * 4 - c * 1 <= 96 * scale) * (c <= 0)
-                if cut_inside:
-                    alphamask *= r * 2 - c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 2 + c >= 0
-            elif part == 3:
-                alphamask = (r * 4 + c * 3 <= 128 * scale) * (c >= 0)
-                if cut_inside:
-                    alphamask *= r * 2 + c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 2 - c >= -16 * scale
-            elif part == 4:
-                alphamask = (r * 2 + c <= 64 * scale) * (c >= 0)
-                if cut_inside:
-                    alphamask *= r * 2 + c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 4 - c * 3 >= -32 * scale
-            elif part == 5:
-                alphamask = (r * 4 + c * 1 <= 96 * scale) * (c >= 0)
-                if cut_inside:
-                    alphamask *= r * 2 + c >= 48 * scale
-                elif not solid:
-                    alphamask *= r * 2 - c >= 0
-            elif part == 6:
-                if cut_inside:
-                    alphamask = (r * 2 + c <= -16 * scale) * (c <= 0)
-                else:
-                    alphamask = 0
-            elif part == 7:
-                if cut_inside:
-                    alphamask = (r * 2 - c <= -16 * scale) * (c >= 0)
-                else:
-                    alphamask = 0
-            else:
-                assert False, f"Unsupported part: {part}"
-        elif style == "extended":
-            if part == 0:
-                alphamask = (r * 2 - c * 1 <= 48 * scale) * (r * 4 + c <= 96 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c >= 0 * scale
-                    alphamask *= r * 2 - c >= 0 * scale
-            elif part == 1:
-                alphamask = (r * 4 - c * 3 <= 128 * scale) * (r * 4 + c * 3 <= 128 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c >= 0 * scale
-                    alphamask *= r * 4 - c >= 0 * scale
-            elif part == 2:
-                alphamask = (r * 4 - c * 1 <= 96 * scale) * (r * 2 + c <= 48 * scale)
-                if not solid:
-                    alphamask *= r * 2 + c >= 0 * scale
-                    alphamask *= r * 4 - c >= 0 * scale
-            elif part == 3:
-                alphamask = (r * 2 - c <= 48 * scale) * (r * 2 + c <= 48 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c >= 0 * scale
-                    alphamask *= r * 4 - c >= 0 * scale
-            elif part == 4:
-                alphamask = (r * 4 - c * 3 <= 128 * scale) * (r * 2 + c <= 64 * scale)
-                if not solid:
-                    alphamask *= r * 2 + c >= -16 * scale
-                    alphamask *= r * 4 - c * 3 >= -32 * scale
-            elif part == 5:
-                alphamask = (r * 4 - c * 1 <= 96 * scale) * (r * 4 + c * 1 <= 96 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c * 3 >= -32 * scale
-                    alphamask *= r * 4 - c * 3 >= -32 * scale
-            elif part == 6:
-                alphamask = (r * 2 - c <= 48 * scale) * (r * 4 + c * 1 <= 96 * scale)
-                if not solid:
-                    alphamask *= r * 2 + c >= -16 * scale
-                    alphamask *= r * 4 - c * 3 >= -32 * scale
-            elif part == 7:
-                alphamask = (r * 2 - c <= 64 * scale) * (r * 4 + c * 3 <= 128 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c * 3 >= -32 * scale
-                    alphamask *= r * 2 - c >= -16 * scale
-            elif part == 8:
-                alphamask = (r * 4 - c * 3 <= 128 * scale) * (r * 4 + c * 3 <= 128 * scale)
-                if not solid:
-                    alphamask *= r * 2 + c >= -16 * scale
-                    alphamask *= r * 2 - c >= -16 * scale
-            elif part == 9:
-                alphamask = (r * 4 - c * 1 <= 96 * scale) * (r * 2 + c <= 48 * scale)
-                if not solid:
-                    alphamask *= r * 4 + c * 3 >= -32 * scale
-                    alphamask *= r * 2 - c >= -16 * scale
+
+def get_left_part(left_parts, r, c, solid, scale):
+    left = np.ones_like(r, dtype=np.uint8) * ((c >= -32 * scale) * (c <= 0 * scale))
+
+    # Top limit - not applicable to solid parts
+    # special case for None which indicates a quarter-base in simple mode
+    if left_parts[2] is None:
+        left *= r >= 8 * scale
+    else:
+        if not solid:
+            if left_parts[2] == left_parts[3]:
+                left *= r * 2 + c >= (-16 * left_parts[3]) * scale
+            elif left_parts[2] == left_parts[3] + 1:
+                left *= r * 4 + c >= (-16 * left_parts[3]) * 2 * scale
             else:
-                assert False, f"Unsupported part: {part}"
-            alphamask *= c >= -32 * scale
-            alphamask *= c <= 32 * scale
-        alpha = img.alpha * alphamask
+                assert left_parts[2] == left_parts[3] - 1
+                left *= r * 4 + c * 3 >= (-16 * left_parts[3]) * 2 * scale
+
+    if left_parts[0] is None:
+        left *= r <= 8 * scale
+    elif left_parts[0] == left_parts[1]:
+        left *= r * 2 - c <= (64 - 16 * left_parts[0]) * scale
+    elif left_parts[0] == left_parts[1] + 1:
+        left *= r * 4 - c <= (64 - 16 * left_parts[0]) * 2 * scale
     else:
+        assert left_parts[0] == left_parts[1] - 1
+        left *= r * 4 - c * 3 <= (64 - 16 * left_parts[0]) * 2 * scale
+
+    return left.astype(np.uint8)
+
+
+def make_foundation_subimage(
+    img: LayeredImage, scale, left_parts, right_parts, nw, ne, y_limit, cut_inside, zshift, solid
+) -> LayeredImage:
+    r = np.arange(img.h)[:, np.newaxis] + img.yofs + 0.5 + zshift * scale
+    c = np.arange(img.w)[np.newaxis] + img.xofs - scale + 0.5
+
+    alphamask = np.zeros((img.h, img.w), dtype=np.uint8)
+    if left_parts is not None:
+        alphamask = np.maximum(alphamask, get_left_part(left_parts, r, c, solid, scale))
+
+    if right_parts is not None:
+        alphamask = np.maximum(alphamask, get_left_part(right_parts, r, -c, solid, scale))
+
+    if cut_inside:
+        alphamask *= (
+            1
+            - (r * 2 + c >= -16 * scale)
+            * (r * 2 - c >= -16 * scale)
+            * (r * 2 + c < 48 * scale)
+            * (r * 2 - c < 48 * scale)
+        ).astype(np.uint8)
+
+    if not solid:
+        if nw:
+            alphamask *= (1 - (c < 0) * (r * 2 + c < 0 * scale) * (r * 4 - c < 64 * scale)).astype(np.uint8)
+        if ne:
+            alphamask *= (1 - (c > 0) * (r * 2 - c < 0 * scale) * (r * 4 + c < 64 * scale)).astype(np.uint8)
+
+    alphamask *= (1 - (r * 4 - c > y_limit * 2 * scale) * (r * 4 + c > y_limit * 2 * scale)).astype(np.uint8)
+
+    if img.alpha is None:
         alpha = None
+        assert img.mask is not None
+        assert img.rgb is None
+        mask = img.mask * alphamask
+    else:
+        alpha = img.alpha * alphamask
+        assert img.rgb is not None
+        mask = img.mask
 
-    return LayeredImage(xofs=img.xofs, yofs=img.yofs, w=img.w, h=img.h, rgb=img.rgb, alpha=alpha, mask=None)
+    return LayeredImage(xofs=img.xofs, yofs=img.yofs, w=img.w, h=img.h, rgb=img.rgb, alpha=alpha, mask=mask)
 
 
-def make_foundation(solid: LayeredImage, ground: LayeredImage, scale, part, style, cut_inside, zshift) -> LayeredImage:
+def make_foundation(
+    solid: LayeredImage, ground: LayeredImage, scale, left_parts, right_parts, nw, ne, y_limit, cut_inside, zshift
+) -> LayeredImage:
     if solid is not None:
-        solid = make_foundation_subimage(solid, scale, part, style, cut_inside, zshift, True)
+        solid = make_foundation_subimage(
+            solid, scale, left_parts, right_parts, nw, ne, y_limit, cut_inside, zshift, True
+        )
     if ground is not None:
-        ground = make_foundation_subimage(ground, scale, part, style, cut_inside, zshift, False)
+        ground = make_foundation_subimage(
+            ground, scale, left_parts, right_parts, nw, ne, y_limit, cut_inside, zshift, False
+        )
     if solid is not None and ground is not None:
         return ground.copy().blend_over(solid)
     return solid or ground

agrf/graphics/cv/foundation_test.py

@@ -12,46 +12,93 @@ def _full_alpha_image(w=16, h=16, xofs=0, yofs=0):
 
 def test_make_foundation_subimage_basic_left_side():
     base = _full_alpha_image()
-    # part 0 targets the left side (c <= 0) when scale=4 and xofs=0
-    out = make_foundation_subimage(base, scale=4, part=0, style="simple", cut_inside=False, zshift=0, solid=True)
+    # part (6, 0) targets the left side (c <= 0) when scale=4 and xofs=0
+    out = make_foundation_subimage(
+        base,
+        scale=4,
+        left_parts=6,
+        right_parts=None,
+        nw=False,
+        ne=False,
+        y_limit=64,
+        cut_inside=False,
+        zshift=0,
+        solid=True,
+    )
     assert out.alpha is not None
     # Left-most column should be non-zero
     assert out.alpha[0, 0] > 0
     # A column clearly on the right should be zero
     assert out.alpha[0, 8] == 0
 
 
-def test_make_foundation_subimage_alpha_none_passthrough():
-    # If input has no alpha, output keeps alpha as None
-    rgb = np.zeros((8, 8, 3), dtype=np.uint8)
-    base = LayeredImage(0, 0, 8, 8, rgb, None, None)
-    out = make_foundation_subimage(base, scale=4, part=0, style="simple", cut_inside=False, zshift=0, solid=True)
-    assert out.alpha is None
-
-
 def test_make_foundation_passthrough_single_input():
     base = _full_alpha_image()
     # Only solid provided
     expected_solid = make_foundation_subimage(
-        base.copy(), scale=4, part=0, style="simple", cut_inside=False, zshift=0, solid=True
+        base.copy(),
+        scale=4,
+        left_parts=6,
+        right_parts=None,
+        nw=False,
+        ne=False,
+        y_limit=64,
+        cut_inside=False,
+        zshift=0,
+        solid=True,
+    )
+    out_solid = make_foundation(
+        base, None, scale=4, left_parts=6, right_parts=None, nw=False, ne=False, y_limit=64, cut_inside=False, zshift=0
     )
-    out_solid = make_foundation(base, None, scale=4, part=0, style="simple", cut_inside=False, zshift=0)
     assert np.array_equal(out_solid.alpha, expected_solid.alpha)
 
     # Only ground provided
     expected_ground = make_foundation_subimage(
-        base.copy(), scale=4, part=0, style="simple", cut_inside=False, zshift=0, solid=False
+        base.copy(),
+        scale=4,
+        left_parts=6,
+        right_parts=None,
+        nw=False,
+        ne=False,
+        y_limit=64,
+        cut_inside=False,
+        zshift=0,
+        solid=False,
+    )
+    out_ground = make_foundation(
+        None, base, scale=4, left_parts=6, right_parts=None, nw=False, ne=False, y_limit=64, cut_inside=False, zshift=0
     )
-    out_ground = make_foundation(None, base, scale=4, part=0, style="simple", cut_inside=False, zshift=0)
     assert np.array_equal(out_ground.alpha, expected_ground.alpha)
 
 
 def test_make_foundation_subimage_zshift_reduces_coverage_for_part0():
     # Use a large y offset to sit near the inequality boundary so zshift has an effect
     base = _full_alpha_image()
     base.yofs = 120
-    out0 = make_foundation_subimage(base, scale=4, part=0, style="simple", cut_inside=False, zshift=0, solid=True)
-    out1 = make_foundation_subimage(base, scale=4, part=0, style="simple", cut_inside=False, zshift=2, solid=True)
+    out0 = make_foundation_subimage(
+        base,
+        scale=4,
+        left_parts=6,
+        right_parts=None,
+        nw=False,
+        ne=False,
+        y_limit=64,
+        cut_inside=False,
+        zshift=0,
+        solid=True,
+    )
+    out1 = make_foundation_subimage(
+        base,
+        scale=4,
+        left_parts=6,
+        right_parts=None,
+        nw=False,
+        ne=False,
+        y_limit=64,
+        cut_inside=False,
+        zshift=2,
+        solid=True,
+    )
     sum0 = int(out0.alpha.sum())
     sum1 = int(out1.alpha.sum())
     assert sum0 > 0