fixed Professional mode

requirements.txt

@@ -61,7 +61,7 @@ s3transfer==0.2.1
 scikit-image==0.16.2
 scipy==1.3.2
 six==1.13.0
-streamlit==0.50.2
+streamlit==0.52.2
 toml==0.10.0
 toolz==0.10.0
 tornado==5.1.1

src/app.py

@@ -21,13 +21,12 @@ else:
                                       ['Simple', 'Professional'])
 
     # select image
-    status, image = select_image(path_to_images)
+    status, image = select_image(path_to_images, interface_type)
     if status == 0:
-        st.title("Can't load image from: " + path_to_images)
+        st.title("Can't load image")
+    if status == 2:
+        st.title("Please, upload the image")
     else:
-        # show title
-        st.title("Demo of Albumentations")
-
         placeholder_params = {
             "image_width": image.shape[1],
             "image_height": image.shape[0],
@@ -57,37 +56,45 @@ else:
             ))
             transform_names = transform_names[:-1]
 
-        original_image = image.copy()
         transforms = []
-        for transform_name in transform_names:
-
+        for i, transform_name in enumerate(transform_names):
             # select the params values
-            st.sidebar.subheader("Params of the : " + transform_name)
-            param_values = show_transform_control(augmentations[transform_name])
+            st.sidebar.subheader("Params of the " + transform_name)
+            param_values = show_transform_control(augmentations[transform_name], i)
+            transforms.append(getattr(A, transform_name)(**param_values))
 
+        try:
             # apply the transformation to the image
-            transforms.append(getattr(A, transform_name)(**param_values))
+            data = A.ReplayCompose(transforms)(image=image)
+            error = 0
+        except ValueError:
+            error = 1
+            st.title("The error has occurred. Most probably you have passed wrong set of parameters. \
+            Check transforms that change the shape of image.")
 
-        data = A.ReplayCompose(transforms)(image=image)
-        augmented_image = data["image"]
+        if error == 0:
+            augmented_image = data["image"]
+            # show title
+            st.title("Demo of Albumentations")
 
-        # TODO add convinient replay compose
-        # applied_params = data["replay"]["transforms"][0]['params']
-        # for k,v in applied_params.items():
-        #     applied_params[k] = str(v)
-        # st.write(applied_params)
-        # st.write(data["replay"])
+            # show the images
+            width_transformed = int(
+                width_original / image.shape[1] * augmented_image.shape[1]
+            )
 
-        # show the images
-        width_transformed = int(
-            width_original / image.shape[1] * augmented_image.shape[1]
-        )
+            st.image(image, caption="Original image", width=width_original)
+            st.image(augmented_image, caption="Transformed image", width=width_transformed)
 
-        st.image(image, caption="Original image", width=width_original)
-        st.image(augmented_image, caption="Transformed image", width=width_transformed)
+            # random values used to get transformations
+            if interface_type == 'Professional':
+                st.subheader("Random params used")
+                random_values = {}
+                for applied_params in data["replay"]["transforms"]:
+                    random_values[applied_params['__class_fullname__'].split('.')[-1]] = applied_params['params']
+                st.write(random_values)
 
-        # print additional info
-        for transform in transforms:
-            st.code(str(transform))
-            show_docstring(transform)
-        show_credentials()
+            # print additional info
+            for transform in transforms:
+                show_docstring(transform)
+                st.code(str(transform))
+            show_credentials()

src/control.py

@@ -3,16 +3,16 @@ import streamlit as st
 # TODO: rename and refactor everything
 
 
-def select_num_interval(param_name: str, limits_list: list, defaults, **kwargs):
+def select_num_interval(param_name: str, limits_list: list, defaults, n_for_hash, **kwargs):
     st.sidebar.subheader(param_name)
     min_max_interval = st.sidebar.slider(
-        "", limits_list[0], limits_list[1], defaults, key=hash(param_name)
+        "", limits_list[0], limits_list[1], defaults, key=hash(param_name + str(n_for_hash))
     )
     return min_max_interval
 
 
 def select_several_nums(
-    param_name, subparam_names, limits_list, defaults_list, **kwargs
+    param_name, subparam_names, limits_list, defaults_list, n_for_hash, **kwargs
 ):
     st.sidebar.subheader(param_name)
     result = []
@@ -22,16 +22,16 @@ def select_several_nums(
     for name, limits, defaults in zip(subparam_names, limits_list, defaults_list):
         result.append(
             st.sidebar.slider(
-                name, limits[0], limits[1], defaults, key=hash(param_name + name)
+                name, limits[0], limits[1], defaults, key=hash(param_name + name + str(n_for_hash))
             )
         )
     return tuple(result)
 
 
-def select_min_max(param_name, limits_list, defaults_list, min_diff=0, **kwargs):
+def select_min_max(param_name, limits_list, defaults_list, n_for_hash, min_diff=0,  **kwargs):
     assert len(param_name) == 2
     result = list(
-        select_num_interval(" & ".join(param_name), limits_list, defaults_list)
+        select_num_interval(" & ".join(param_name), limits_list, defaults_list, n_for_hash)
     )
     if result[1] - result[0] < min_diff:
         diff = min_diff - result[1] + result[0]
@@ -44,12 +44,12 @@ def select_min_max(param_name, limits_list, defaults_list, min_diff=0, **kwargs)
     return tuple(result)
 
 
-def select_RGB(param_name, **kwargs):
+def select_RGB(param_name, n_for_hash, **kwargs):
     result = select_several_nums(
         param_name,
         subparam_names=["Red", "Green", "Blue"],
         limits_list=[[0, 255], [0, 255], [0, 255]],
-        defaults_list=[0, 0, 0],
+        defaults_list=[0, 0, 0], n_for_hash = n_for_hash
     )
     return tuple(result)
 
@@ -61,15 +61,15 @@ def replace_none(string):
         return string
 
 
-def select_radio(param_name, options_list, **kwargs):
+def select_radio(param_name, options_list, n_for_hash, **kwargs):
     st.sidebar.subheader(param_name)
-    result = st.sidebar.radio("", options_list, key=hash(param_name))
+    result = st.sidebar.radio("", options_list, key=hash(param_name + str(n_for_hash)))
     return replace_none(result)
 
 
-def select_checkbox(param_name, defaults, **kwargs):
+def select_checkbox(param_name, defaults, n_for_hash, **kwargs):
     st.sidebar.subheader(param_name)
-    result = st.sidebar.checkbox("True", defaults, key=hash(param_name))
+    result = st.sidebar.checkbox("True", defaults, key=hash(param_name + str(n_for_hash)))
     return result
 
 

src/utils.py

@@ -1,5 +1,6 @@
 import cv2
 import os
+import numpy as np
 import json
 import argparse
 
@@ -43,6 +44,17 @@ def load_image(image_name: str, path_to_folder: str, bgr2rgb: bool = True):
     return image
 
 
+def upload_image(bgr2rgb: bool = True):
+    """Uoload the image
+    Args:
+        bgr2rgb (bool): converts BGR image to RGB if True
+    """
+    file = st.sidebar.file_uploader("Upload your image (jpg, jpeg, or png)", ["jpg", "jpeg", "png"])
+    image = cv2.imdecode(np.fromstring(file.read(), np.uint8), 1)
+    if bgr2rgb:
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    return image
+
 @st.cache
 def load_augmentations_config(
     placeholder_params: dict, path_to_config: str = "configs/augmentations.json"

src/visuals.py

@@ -2,27 +2,40 @@ import cv2
 import streamlit as st
 
 from control import param2func
-from utils import get_images_list, load_image
+from utils import get_images_list, load_image, upload_image
 
 
 def show_logo():
     st.image(load_image("logo.png", "../images"), format="PNG")
 
 
-def select_image(path_to_images: str):
+def select_image(path_to_images: str, interface_type:str = 'Simple'):
     image_names_list = get_images_list(path_to_images)
     if len(image_names_list) < 1:
         return 0, 0
     else:
-        try:
+        if interface_type == 'Professional':
+            image_name = st.sidebar.selectbox("Select an image:", image_names_list + ["Upload my image"])
+        else:
             image_name = st.sidebar.selectbox("Select an image:", image_names_list)
-            image = load_image(image_name, path_to_images)
-            return 1, image
-        except cv2.error:
-            return 0, 0
 
+        if image_name != 'Upload my image':
+            try:
+                image = load_image(image_name, path_to_images)
+                return 1, image
+            except cv2.error:
+                return 0, 0
+        else:
+            try:
+                image = upload_image()
+                return 1, image
+            except cv2.error:
+                return 0, 0
+            except AttributeError:
+                return 2, 0
 
-def show_transform_control(transform_params: dict) -> dict:
+
+def show_transform_control(transform_params: dict, n_for_hash: int) -> dict:
     param_values = {"p": 1.0}
     if len(transform_params) == 0:
         st.sidebar.text("Transform has no parameters")
@@ -30,11 +43,11 @@ def show_transform_control(transform_params: dict) -> dict:
         for param in transform_params:
             control_function = param2func[param["type"]]
             if isinstance(param["param_name"], list):
-                returned_values = control_function(**param)
+                returned_values = control_function(**param, n_for_hash = n_for_hash)
                 for name, value in zip(param["param_name"], returned_values):
                     param_values[name] = value
             else:
-                param_values[param["param_name"]] = control_function(**param)
+                param_values[param["param_name"]] = control_function(**param,n_for_hash = n_for_hash)
     return param_values
 
 
@@ -63,5 +76,5 @@ def show_credentials():
 
 def show_docstring(obj_with_ds):
     st.markdown("* * *")
-    st.subheader("Docstring:")
+    st.subheader("Docstring for " + obj_with_ds.__class__.__name__)
     st.text(obj_with_ds.__doc__)