Upload 4 files

app.py

@@ -0,0 +1,46 @@
+import streamlit as st
+from PIL import Image
+from texture_transfer import create_image_tile, create_layover, create_image_cutout, paste_image
+
+st.title("Texture Correction App")
+
+if 'clicked' not in st.session_state:
+    st.session_state.clicked = False
+
+
+def click_button():
+    st.session_state.clicked = True
+
+
+with st.sidebar:
+    st.text("Play around this values")
+    opacity = st.slider("Control opacity", min_value=0.0, max_value=100.0, value=100.0)
+
+product, generated, texture_correct = st.columns(3)
+with product:
+    st.header("Input product texture patch")
+    product_image = st.file_uploader("Patch of the Garment(Cut out an area from the garment)",
+                                     type=["png", "jpg", "jpeg"])
+    if product_image:
+        st.image(product_image)
+
+with generated:
+    st.header("Input generated product Image & Mask")
+    generated_image = st.file_uploader("Generated Image", type=["png", "jpg", "jpeg"])
+    gen_image_mask = st.file_uploader("Generated Mask", type=["png", "jpg", "jpeg"])
+    if generated_image:
+        st.image(generated_image)
+
+with texture_correct:
+    st.button("Texture Correct", on_click=click_button)
+    if st.session_state.clicked:
+        with st.spinner("Texture correcting🫡..."):
+            product_image = Image.open(generated_image)
+            product_image_dim = product_image.size
+            x_dim = product_image_dim[0]
+            y_dim = product_image_dim[0]
+            create_image_tile(product_image, x_dim, y_dim)
+            overlay = create_layover(generated_image, 'tiled_image.png', opacity)
+            create_image_cutout('lay_over_image.png', gen_image_mask)
+            paste_image(generated_image, 'cut_out_image.png', gen_image_mask)
+            st.image("result.png", caption="Texture Corrected Image", use_column_width=True)

create_print_layover.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+
+def assert_image_format(image, fcn_name: str, arg_name: str, force_alpha: bool = True):
+    if not isinstance(image, np.ndarray):
+        err_msg = 'The blend_modes function "{fcn_name}" received a value of type "{var_type}" for its argument ' \
+                  '"{arg_name}". The function however expects a value of type "np.ndarray" for this argument. Please ' \
+                  'supply a variable of type np.ndarray to the "{arg_name}" argument.' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, var_type=str(type(image).__name__))
+        raise TypeError(err_msg)
+
+    if not image.dtype.kind == 'f':
+        err_msg = 'The blend_modes function "{fcn_name}" received a numpy array of dtype (data type) kind ' \
+                  '"{var_kind}" for its argument "{arg_name}". The function however expects a numpy array of the ' \
+                  'data type kind "f" (floating-point) for this argument. Please supply a numpy array with the data ' \
+                  'type kind "f" (floating-point) to the "{arg_name}" argument.' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, var_kind=str(image.dtype.kind))
+        raise TypeError(err_msg)
+
+    if not len(image.shape) == 3:
+        err_msg = 'The blend_modes function "{fcn_name}" received a {n_dim}-dimensional numpy array for its argument ' \
+                  '"{arg_name}". The function however expects a 3-dimensional array for this argument in the shape ' \
+                  '(height x width x R/G/B/A layers). Please supply a 3-dimensional numpy array with that shape to ' \
+                  'the "{arg_name}" argument.' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, n_dim=str(len(image.shape)))
+        raise TypeError(err_msg)
+
+    if force_alpha and not image.shape[2] == 4:
+        err_msg = 'The blend_modes function "{fcn_name}" received a numpy array with {n_layers} layers for its ' \
+                  'argument "{arg_name}". The function however expects a 4-layer array representing red, green, ' \
+                  'blue, and alpha channel for this argument. Please supply a numpy array that includes all 4 layers ' \
+                  'to the "{arg_name}" argument.' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, n_layers=str(image.shape[2]))
+        raise TypeError(err_msg)
+
+
+def assert_opacity(opacity, fcn_name: str, arg_name: str = 'opacity'):
+    if not isinstance(opacity, float) and not isinstance(opacity, int):
+        err_msg = 'The blend_modes function "{fcn_name}" received a variable of type "{var_type}" for its argument ' \
+                  '"{arg_name}". The function however expects the value passed to "{arg_name}" to be of type ' \
+                  '"float". Please pass a variable of type "float" to the "{arg_name}" argument of function ' \
+                  '"{fcn_name}".' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, var_type=str(type(opacity).__name__))
+        raise TypeError(err_msg)
+
+    if not 0.0 <= opacity <= 1.0:
+        err_msg = 'The blend_modes function "{fcn_name}" received the value "{val}" for its argument "{arg_name}". ' \
+                  'The function however expects that the value for "{arg_name}" is inside the range 0.0 <= x <= 1.0. ' \
+                  'Please pass a variable in that range to the "{arg_name}" argument of function "{fcn_name}".' \
+            .format(fcn_name=fcn_name, arg_name=arg_name, val=str(opacity))
+        raise ValueError(err_msg)
+
+
+def _compose_alpha(img_in, img_layer, opacity):
+    comp_alpha = np.minimum(img_in[:, :, 3], img_layer[:, :, 3]) * opacity
+    new_alpha = img_in[:, :, 3] + (1.0 - img_in[:, :, 3]) * comp_alpha
+    np.seterr(divide='ignore', invalid='ignore')
+    ratio = comp_alpha / new_alpha
+    ratio[ratio == np.NAN] = 0.0
+    return ratio
+
+
+def create_hard_light_layover(img_in, img_layer, opacity, disable_type_checks: bool = False):
+    if not disable_type_checks:
+        _fcn_name = 'hard_light'
+        assert_image_format(img_in, _fcn_name, 'img_in')
+        assert_image_format(img_layer, _fcn_name, 'img_layer')
+        assert_opacity(opacity, _fcn_name)
+    img_in_norm = img_in / 255.0
+    img_layer_norm = img_layer / 255.0
+    ratio = _compose_alpha(img_in_norm, img_layer_norm, opacity)
+    comp = np.greater(img_layer_norm[:, :, :3], 0.5) \
+           * np.minimum(1.0 - ((1.0 - img_in_norm[:, :, :3])
+                               * (1.0 - (img_layer_norm[:, :, :3] - 0.5) * 2.0)), 1.0) \
+           + np.logical_not(np.greater(img_layer_norm[:, :, :3], 0.5)) \
+           * np.minimum(img_in_norm[:, :, :3] * (img_layer_norm[:, :, :3] * 2.0), 1.0)
+    ratio_rs = np.reshape(np.repeat(ratio, 3), [comp.shape[0], comp.shape[1], comp.shape[2]])
+    img_out = comp * ratio_rs + img_in_norm[:, :, :3] * (1.0 - ratio_rs)
+    img_out = np.nan_to_num(np.dstack((img_out, img_in_norm[:, :, 3])))  # add alpha channel and replace nans
+    return img_out * 255.0

requirements.txt

@@ -0,0 +1,4 @@
+streamlit~=1.36.0
+opencv-python~=4.10.0.84
+numpy~=2.0.0
+pillow~=10.4.0

texture_transfer.py

@@ -0,0 +1,71 @@
+from PIL import Image, ImageOps
+import numpy as np
+from create_print_layover import create_hard_light_layover
+import cv2
+
+
+def create_layover(background_image, layer_image, opacity):
+    background_img_raw = Image.open(background_image)
+    background_img_raw = background_img_raw.convert("RGBA")
+    background_img = np.array(background_img_raw)
+    background_img_float = background_img.astype(float)
+    foreground_img_raw = Image.open(layer_image)
+    foreground_img_raw = foreground_img_raw.convert("RGBA")
+    foreground_img = np.array(foreground_img_raw)
+    foreground_img_float = foreground_img.astype(float)
+    blended_img_float = create_hard_light_layover(background_img_float, foreground_img_float, opacity)
+    blended_img = np.uint8(blended_img_float)
+    blended_img_raw = Image.fromarray(blended_img)
+    output_path = "lay_over_image.png"
+    blended_img_raw.save(output_path)
+    return output_path
+
+
+def create_image_tile(input_patch, x_dim, y_dim):
+    input_image = Image.open(input_patch)
+    input_image = input_image.convert("RGB")
+    width, height = input_image.size
+    output_image = Image.new("RGB", (x_dim, y_dim))
+    for y in range(0, y_dim, height):
+        for x in range(0, x_dim, width):
+            region_height = min(height, y_dim - y)
+            region_width = min(width, x_dim - x)
+            region = input_image.crop((0, 0, region_width, region_height))
+            output_image.paste(region, (x, y))
+    output_image.save('tiled_image.png')
+
+
+def create_image_cutout(texture_transfer_image, actual_mask):
+    image = Image.open(texture_transfer_image)
+    mask = Image.open(actual_mask).convert('L')
+    if mask.size != image.size:
+        image = image.resize(mask.size, Image.Resampling.NEAREST)
+    image_np = np.array(image)
+    mask_np = np.array(mask)
+    binary_mask = (mask_np > 127).astype(np.uint8) * 255
+    masked_image_np = image_np * np.expand_dims(binary_mask, axis=-1) // 255
+    masked_image = Image.fromarray(masked_image_np)
+    masked_image.save('cut_out_image.png')
+
+
+def paste_image(base_image_path, cutout_image_path, mask_path):
+    background = Image.open(base_image_path).convert("RGB")
+    cutout = Image.open(cutout_image_path)
+    mask = Image.open(mask_path).convert("L")
+    if cutout.mode == 'RGBA':
+        cutout_rgb = cutout.convert("RGB")
+        cutout_alpha = cutout.split()[-1]
+    else:
+        cutout_rgb = cutout
+        cutout_alpha = mask
+    cutout_rgb = cutout_rgb.resize(background.size, Image.Resampling.NEAREST)
+    cutout_alpha = cutout_alpha.resize(background.size, Image.Resampling.NEAREST)
+    cutout_alpha_np = np.array(cutout_alpha)
+    binary_mask = (cutout_alpha_np > 128).astype(np.uint8) * 255
+    cutout_rgb_np = np.array(cutout_rgb)
+    background_np = np.array(background)
+    cutout_masked = cutout_rgb_np * np.expand_dims(binary_mask, axis=-1) // 255
+    background_masked = background_np * np.expand_dims(255 - binary_mask, axis=-1) // 255
+    result_np = cutout_masked + background_masked
+    result = Image.fromarray(result_np.astype(np.uint8))
+    result.save('result.png')