update slider names, add md

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*png* filter=lfs diff=lfs merge=lfs -text

app.py

@@ -47,7 +47,7 @@ def main(argv, low_resource_demo=True):
     if args.keyboard:
         image_control = KeyboardControl(0, [0, len(img_list)-1], keydown="3", keyup="9", modulo=True)
     else:
-        image_control = (0, [0, len(img_list)-1])
+        image_control = (0, [0, len(img_list)-1], "input image selector")
     interactive(image_index=image_control)(image_selector)
     plug_crop_selector(num_pad=args.keyboard, low_resources=low_resource_demo)
     if not low_resource_demo:
@@ -55,10 +55,16 @@ def main(argv, low_resource_demo=True):
     if args.backend != "gradio":
         plug_morph_canvas()
     model_dict = get_default_models(args.experiments, Path(args.models_storage), keyboard_control=args.keyboard)
+    markdown_description = "# 🔍 Blind image deblurring - READ MORE HERE \n"
+    markdown_description += open("description.md", 'r').read()
+
     interactive_pipeline(
         gui=backend,
         cache=True,
-        safe_input_buffer_deepcopy=False
+        safe_input_buffer_deepcopy=False,
+        sliders_layout="smart",
+        sliders_per_row_layout=3,
+        markdown_description=markdown_description,
     )(natural_inference_pipeline)(
         img_list,
         model_dict

description.md

@@ -0,0 +1,40 @@
+# Blind deblurring from synthetic data
+MVA project 2024 on [image restoration](https://delires.wp.imt.fr/)
+
+- Jamy Lafenetre
+- Balthazar Neveu
+
+------
+
+In the paper [Synthetic images as a regularity prior for image
+restoration neural networks](https://hal.science/hal-03186499/file/papier_SSVM%20%281%29.pdf) by 
+*Raphaël Achddou, Yann Gousseau, Saïd Ladjal*, it was shown that a deep neural network can be trained for denoising solely from synthetic dead leave images and does perform relatively well on natural images. 
+
+We propose to explore several tracks:
+- Use a [NAFNET](https://github.com/megvii-research/NAFNet) architecture
+- Extend deadleaves with extra primitives (lines, diamond shapes, colored gradients)
+- Try to see if the generalization property to natural images observed in denoising holds for deblurring. 
+
+
+![](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial/resolve/main/illustrations/blind_deblur_teaser_figure.png)
+
+
+We first validated that NAFNet trained on deadleaves performed well on the blind denoising task. Below you can see that it also performs correctly on natural images, although the performances are not as good as a network purely trained on natural images.
+
+| Qualitative results at SNR in = 20dB | Quantitative results
+| :---: | :---: |
+| ![](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial/resolve/main/illustrationsdeadleaves_vs_natural_with_psnr.png) | ![](
+https://huggingface.co/spaces/balthou/interactive-pipe-tutorial/resolve/main/illustrations/cross_val_natural.png)
+
+
+Finally, when applying the deadleaves training to the blind deblurring problem, one of the advantage we have notticed is that the network always tries to deblur even when the level of blur is high. On the contrary, when trained on natural images, the NAFNEt does not work so well when the blur level is too big.
+|Blind deblurring results|
+|:----:|
+| ![](illustrations/deblur_results.png) |
+|Deblurring result for different amount of blur, using Nafnet trained on Div2K or deadleaves. From left to right column: ”small”, ”mild” and ”big” blur kernels to degrade the input. **Top row**: input image. **Middle row**: output of NafNet trained on deadleaves.  **Bottom row**: output of NafNet trained on Div2K.|
+|![](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial/resolve/main/illustrations/deblur_table.png) |
+
+**Conclusion** : 
+- Using extra primitives to pure deadleaves seems like a good idea but did not bring as much as we'd expected. A rework by adding anisotropy and extra geometric shapes could lead to significantly better results.
+- Training on deadleaves images brings a lot of stability in trainings (as the image distribution is basically always the same, providing a fair amount of learning signal) and can be seen as a good pretext task before to the real dataset.
+

src/rstor/analyzis/interactive/crop.py

@@ -51,8 +51,8 @@ def plug_crop_selector(num_pad: bool = False, low_resources: bool = False):
     else:
         size_control = (9., [6., 13., 0.3], "crop size", ["+", "-"])
     interactive(
-        center_x=(0.5, [0., 1.], "cx", ["4" if num_pad else "left", "6" if num_pad else "right"]),
-        center_y=(0.5, [0., 1.], "cy", ["8" if num_pad else "up", "2" if num_pad else "down"]),
+        center_x=(0.5, [0., 1.], "crop horizontally", ["4" if num_pad else "left", "6" if num_pad else "right"]),
+        center_y=(0.5, [0., 1.], "crop vertically", ["8" if num_pad else "up", "2" if num_pad else "down"]),
         size=size_control
     )(crop_selector)
 

src/rstor/analyzis/interactive/degradation.py

@@ -50,7 +50,7 @@ def get_blur_kernel_box(ksize=3):
 
 
 @interactive(
-    blur_index=(0, [-1, 2])
+    blur_index=(0, [0, 2], "blur kernel selection")
 )
 def get_blur_kernel(blur_index: int = -1, global_params={}):
     if blur_index == -1:

src/rstor/analyzis/interactive/pipelines.py

@@ -43,6 +43,11 @@ def morph_canvas(canvas=CANVAS[0], global_params={}):
     global_params["__pipeline"].outputs = CANVAS_DICT[canvas]
     return None
 
+def visualize_kernel(kernel, global_params={}):
+    kernel_amplif = kernel.copy()
+    # kernel_amplif = kernel_amplif - kernel_amplif.min() / (kernel_amplif.max() - kernel_amplif.min())
+    kernel_amplif = (kernel_amplif * 10).clip(0, 1)
+    return kernel_amplif
 
 def natural_inference_pipeline(input_image_list: List[np.ndarray], models_dict: dict):
     model = model_selector(models_dict)
@@ -51,12 +56,13 @@ def natural_inference_pipeline(input_image_list: List[np.ndarray], models_dict:
     groundtruth = crop(img_clean)
     blur_kernel = get_blur_kernel()
     degraded = degrade_blur(groundtruth, blur_kernel)
-    degraded = degrade_noise(degraded)
-    blur_kernel = rescale_thumbnail(blur_kernel)
+    # degraded = degrade_noise(degraded)
+    kernel_amplif = visualize_kernel(blur_kernel)
+    kernel_amplif = rescale_thumbnail(kernel_amplif)
     restored = infer(degraded, model)
     # configure_metrics()
     # get_metrics_restored(restored, groundtruth)
     # get_metrics_degraded(degraded, groundtruth)
     # morph_canvas()
     # return [[degraded, restored], [blur_kernel, groundtruth]]
-    return [degraded, restored, groundtruth, blur_kernel]
+    return [degraded, restored, groundtruth, kernel_amplif]