add success ribons + difficulty (patch size)

app.py

@@ -1,4 +1,5 @@
 from interactive_pipe import interactive_pipeline, interactive, Image
+from typing import Tuple
 import numpy as np
 
 # Helper functions
@@ -21,19 +22,50 @@ def get_crop(img, pos_x, pos_y, crop_size=0.1):
 # -----------------
 
 
-@interactive(seed=(45, [0, 100], "Puzzle seed"))
-def generate_random_puzzle(seed: int = 45, context: dict = {}):
+def generate_feedback_ribbon() -> Tuple[np.ndarray, np.ndarray]:
+    """Generate green and red ribbons for feedback"""
+    flat_array = np.ones((800, 12, 3))
+    colors = [[0., 1., 0.], [1., 0., 0.]]
+    ribbons = [flat_array*np.array(col)[None, None, :] for col in colors]
+    return ribbons[0], ribbons[1]
+
+
+DIFFICULY = {"easy": 0.18, "medium": 0.1, "hard": 0.05}
+DIFFICULY_LEVELS = list(DIFFICULY.keys())
+
+
+@interactive(
+    seed=(45, [0, 100], "Puzzle seed"),
+    difficulty=(DIFFICULY_LEVELS[0], DIFFICULY_LEVELS, "Difficulty")
+)
+def generate_random_puzzle(
+    seed: int = 45,
+    difficulty: str = DIFFICULY_LEVELS[0],
+    context: dict = {}
+):
+    """Generate random puzzle configuration and store in context.
+
+    Configuration = 2D position and flip/mirror.
+    Freeze seed for reproducibility.
+    """
     np.random.seed(seed)
     pos_x, pos_y = np.random.uniform(0.2, 0.8, 2)
     context["puzzle_pos"] = (pos_x, pos_y)
     context["puzzle_flip_mirror"] = np.random.choice([True, False], 2)
+    context["puzzle_piece_size"] = DIFFICULY.get(difficulty, 0.18)
 
 
-def create_puzzle(img, intensity: float = 0.4, context: dict = {}):
+def create_puzzle(
+    img: np.ndarray,
+    intensity: float = 0.4,
+    context: dict = {}
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Extract puzzle piece from image. Make a dark hole where the """
     out = img.copy()
     x_gt, y_gt = context["puzzle_pos"]
     flip_gt, mirror_gt = context["puzzle_flip_mirror"]
-    cs_x, cs_y = get_crop(img, x_gt, y_gt)
+    cs_x, cs_y = get_crop(
+        img, x_gt, y_gt, crop_size=context["puzzle_piece_size"])
     crop = img[cs_y[0]:cs_y[1], cs_x[0]:cs_x[1], ...]
     out[cs_y[0]:cs_y[1], cs_x[0]:cs_x[1]] = intensity*crop
     crop = flip_image(crop, flip=flip_gt, mirror=mirror_gt)
@@ -50,6 +82,7 @@ def flip_mirror_piece(
     mirror: bool = False,
     context: dict = {}
 ) -> np.ndarray:
+    """Flip and/or mirror the puzzle piece."""
     context["user_flip_mirror"] = (flip, mirror)
     return flip_image(piece.copy(), flip=flip, mirror=mirror)
 
@@ -65,9 +98,11 @@ def place_puzzle(
     pos_y: float = 0.5,
     context: dict = {}
 ) -> np.ndarray:
+    """Place the puzzle piece at the user-defined position."""
     out = puzzle.copy()
     context["user_pos"] = (pos_x, pos_y)
-    cp_x, cp_y = get_crop(img, pos_x, pos_y)
+    cp_x, cp_y = get_crop(
+        img, pos_x, pos_y, crop_size=context["puzzle_piece_size"])
     out[cp_y[0]:cp_y[1], cp_x[0]:cp_x[1]] = piece
     return out
 
@@ -79,7 +114,8 @@ TOLERANCE_LEVELS = list(TOLERANCES.keys())
 @interactive(
     tolerance=(TOLERANCE_LEVELS[0], TOLERANCE_LEVELS, "Tolerance")
 )
-def check_puzzle(tolerance: str = "low", context: dict = {}):
+def check_puzzle(tolerance: str = "low", context: dict = {}) -> None:
+    """Check if the user placed the puzzle piece correctly."""
     x_gt, y_gt = context["puzzle_pos"]
     flip_gt, mirror_gt = context["puzzle_flip_mirror"]
     x, y = context["user_pos"]
@@ -91,26 +127,30 @@ def check_puzzle(tolerance: str = "low", context: dict = {}):
     context["success"] = success
 
 
-def show_feedback(context: dict = {}):
+def display_feedback(
+    puzzle: np.ndarray,
+    ok_ribbon: np.ndarray,
+    nok_ribbon: np.ndarray,
+    context: dict = {}
+) -> np.ndarray:
     success = context["success"]
-    flat_array = np.ones((256, 256, 3))
-    if success:
-        return flat_array*np.array([0., 1., 0.])[None, None, :]
-    else:
-        return flat_array*np.array([1., 0., 0.])[None, None, :]
+    ribbon = ok_ribbon if success else nok_ribbon
+    out = np.hstack([puzzle, ribbon[:puzzle.shape[0], ...]])
+    return out
 
 # pipeline definition
 # -------------------
 
 
 def captcha_pipe(inp):
+    ok_ribbon, nok_ribbon = generate_feedback_ribbon()
     generate_random_puzzle()
     puzzle, puzzle_piece = create_puzzle(inp)
     puzzle_piece = flip_mirror_piece(puzzle_piece)
     puzzle = place_puzzle(puzzle, puzzle_piece)
     check_puzzle()
-    validity = show_feedback()
-    return [puzzle_piece, puzzle, validity]
+    puzzle = display_feedback(puzzle, ok_ribbon, nok_ribbon)
+    return puzzle
 
 
 if __name__ == "__main__":