update doc / comments

app.py

@@ -7,16 +7,19 @@ from interactive_pipe import (
 )
 from transformers import pipeline
 
-# -------------------
-# Processing blocks
-# -------------------
+# ----------------------------
+# Processing blocks definition
+# ----------------------------
 
 
 @interactive(
-    background_color=("green", ["green", "blue", "red"]),  # dropdown menu (str)
-    border_size=(0.05, [0., 0.3]),  # continuous slider (float)
+    background_color=("green", ["green", "blue", "red"]),
+    border_size=(0.05, [0., 0.3]),
 )
-def generate_background(background_color="green", border_size: float = 0.) -> np.ndarray:
+def generate_background(
+    background_color: str = "green",  # dropdown menu (str)
+    border_size: float = 0.   # continuous slider (float)
+) -> np.ndarray:
     out = np.zeros((256, 256, 3))  # Initial background set to black
     border_int = int(border_size * 256)
     out[
@@ -28,17 +31,17 @@ def generate_background(background_color="green", border_size: float = 0.) -> np
 
 
 @interactive(
-    radius=(0.005, [0., 0.01]),  # continuous slider (float)
-    spread=(1., [0., 2.]),  # continuous slider (float)
+    radius=(0.005, [0., 0.01]),
+    spread=(1., [0., 2.]),
     geometric_shape=("snooker", ["snooker", "circle", "traffic light"]),
 )
 def add_circles(
     background: np.ndarray,
-    radius: float = 0.,
-    spread: float = 1.,
-    geometric_shape: str = "snooker",
+    radius: float = 0.,  # continuous slider (float)
+    spread: float = 1.,  # continuous slider (float)
+    geometric_shape: str = "snooker",  # dropdown menu (str)
 ) -> np.ndarray:
-    out = background.copy()
+    out = background.copy()  # Perform a copy to avoid inplace modifications!
     x, y = np.meshgrid(
         np.linspace(-1, 1, out.shape[1]), np.linspace(-1, 1, out.shape[0]))
     balls = [
@@ -51,14 +54,14 @@ def add_circles(
         ((0.075, -0.725), [1, 0, 0]),
     ]
     circle_clock = [
-        ((np.cos(angle), np.sin(angle)), [1, 1, 0]) for angle in np.linspace(0, 2*np.pi, 12)
+        ((0.7*np.cos(angle), 0.7*np.sin(angle)), [1, 1, 0])
+        for angle in np.linspace(0, 2*np.pi, 12)
     ]
     traffic_light = [
         ((0.0, 0.0), [1, 0.8, 0]),
         ((0.0, 0.12), [0, 1, 0]),
         ((0.0, -0.12), [1, 0, 0])
     ]
-
     chosen_pattern = {"circle": circle_clock, "snooker": balls,
                       "traffic light": traffic_light}[geometric_shape]
     for (cx, cy), color in chosen_pattern:
@@ -84,24 +87,43 @@ def add_details(img: np.ndarray, add_stick: bool = False) -> np.ndarray:
     seed=(42, [-1, 100])
 )
 def add_noise(img: np.ndarray, noise_level: float = 0., seed: int = 42):
-    np.random.seed(seed)
+    if seed > 0:
+        # If you do not set the seed, the noise will be different at each call
+        # So changing any slider value will change the noise pattern...
+        # This is something you want to avoid in practice in graphical user interfaces!
+        np.random.seed(seed)
     return (img + np.random.normal(0, noise_level, img.shape)).clip(0., 1.)
 
 
 @interactive(detect=(True, "Enable classification"))
-def apply_classifier(img, context={}, detect=False):
-    result = {}
+def apply_classifier(
+    img: np.ndarray,
+    context: dict = {},
+    detect: bool = False
+) -> None:
     if detect:
         if not context.get("clf", None):
             context["clf"] = pipeline(
-                "image-classification", model="google/vit-base-patch16-224")
+                "image-classification",
+                model="google/vit-base-patch16-224"
+            )
+            # Context is used to store the classification pipeline
+            # and avoid reloading it.
         result = context["clf"](Image.fromarray((img*255).astype(np.uint8)))
     else:
         result = [{"score": 0., "label": "No classification"}]*5
+    # Context is shared between all interactive blocks.
+    # We also store the classification result inside this dictionary
+    # We do not return classification results.
+    # as these are not image/audio buffers!
+    # In display_result, we'll show some curves based
+    # on the classification results.
     context["result"] = result
 
 
-def display_result(context={}):
+def display_result(context: dict = {}) -> Curve:
+    # Context is shared between all interactive blocks.
+    # We can access the classification result here.
     result_dict = context.get("result", [])
     curves = [
         SingleCurve(
@@ -122,7 +144,7 @@ def display_result(context={}):
 # -------------------
 
 
-def tutorial_pipeline():
+def classification_tutorial_pipeline():
     background = generate_background()
     foreground = add_details(background)
     foreground = add_circles(foreground)
@@ -132,6 +154,10 @@ def tutorial_pipeline():
     return [[background, foreground], [noisy_input, result_curve]]
 
 
+# ----------------------------------------------------------
+# Main:
+# allows choosing backend through the command line `-b qt`
+# ----------------------------------------------------------
 if __name__ == "__main__":
     BACKEND_OPTIONS = ["gradio", "qt", "mpl"]
     parser = argparse.ArgumentParser()
@@ -140,5 +166,8 @@ if __name__ == "__main__":
     args = parser.parse_args()
     md_description = "# 🔍 EXAMPLE Interactive-pipe + machine learning \n"
     md_description += "```python\n"+open(__file__, 'r').read()+"```\n"
-    interactive_pipeline(gui=args.backend, markdown_description=md_description)(
-        tutorial_pipeline)()
+    classification_tutorial_pipeline_interactive = interactive_pipeline(
+        gui=args.backend,
+        markdown_description=md_description,
+    )(classification_tutorial_pipeline)
+    classification_tutorial_pipeline_interactive()