copied local files. docker initial setup

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

compColors.py

@@ -0,0 +1,120 @@
+#This file generates Complementary Colours palletes using three different alghoritms:
+#Adjacent (https://itsphbytes.wordpress.com/2016/09/25/getting-adjacent-colors-python-code/),
+#Complementary (https://www.101computing.net/complementary-colours-algorithm/) and Gradient.
+#The Gradient alghoritm is based on the code from https://stackoverflow.com/questions/22607043/python-generate-color-palette-from-image
+
+import colorsys
+
+def gradient_colors(color1, color2):
+    """
+    It takes two colors and returns a list of 5 colors that are
+    complementary to the two colors. Basically is a gradient between
+    the two colors.
+    """
+    if color1.startswith('#'):
+        color1 = color1[1:]
+    if color2.startswith('#'):
+        color2 = color2[1:]
+    # Convert hex colors to RGB
+    color1_rgb = tuple(int(color1[i:i+2], 16) for i in (0, 2, 4))
+    color2_rgb = tuple(int(color2[i:i+2], 16) for i in (0, 2, 4))
+
+    # Calculate the difference between the two colors
+    diff = [c2 - c1 for c1, c2 in zip(color1_rgb, color2_rgb)]
+
+    # Generate the palette
+    palette = []
+    for i in range(5):
+        r = color1_rgb[0] + diff[0] * i / 4
+        g = color1_rgb[1] + diff[1] * i / 4
+        b = color1_rgb[2] + diff[2] * i / 4
+        palette.append('#%02x%02x%02x' % (int(r), int(g), int(b)))
+
+    return palette
+
+
+def complementary_colors(hexcolor):
+    # Check if the input starts with '#'. If it does, remove it.
+    if hexcolor.startswith('#'):
+        hexcolor = hexcolor[1:]
+    
+    # Convert hex to RGB
+    r = int(hexcolor[0:2], 16)
+    g = int(hexcolor[2:4], 16)
+    b = int(hexcolor[4:6], 16)
+    
+    # Calculate complementary colors
+    comp_r = 255 - r
+    comp_g = 255 - g
+    comp_b = 255 - b
+    
+    # Convert RGB back to hex
+    comp_hex = "#{:02X}{:02X}{:02X}".format(comp_r, comp_g, comp_b)
+    
+    return comp_hex
+
+
+# Module to convert rgb to hex
+def rgb_to_hex(rgb):
+    return '#%02X%02X%02X' % (rgb)
+ 
+# Module to convert hex to rgb
+def hex_to_rgb(value):
+    value = value.lstrip('#')
+    return tuple(int(value[i:i+2], 16) for i in (0, 2 ,4))
+ 
+# This module gets the adjacent colors.
+# They can be obtained by rotating the color by 30 and 360
+# degrees.
+def adjacent_colors(color):
+    # List to hold two colors
+    adjacent_colors = []
+ 
+    # Get the RGB
+    (r, g, b) = hex_to_rgb(color)
+ 
+    # Set the degree
+    d = 30/360
+ 
+    # Values has to be between 0 to 1
+    r = r / 255.0
+    g = g / 255.0
+    b = b / 255.0
+ 
+    # Convert to HLS using colorsys
+    h, l, s = colorsys.rgb_to_hls(r, g, b)
+ 
+    # Rotate the color
+    h = [(h+d) % 1 for d in (-d, d)]
+ 
+    # For both the colors, convert back to RGB and
+    # load to list
+    for hi in h:
+        r, g, b = colorsys.hls_to_rgb(hi, l, s)
+        r = int(r * 255.0)
+        g = int(g * 255.0)
+        b = int(b * 255.0)
+        hex_val = rgb_to_hex((r,g,b))
+ 
+        adjacent_colors.append(hex_val)
+    print(adjacent_colors)
+    return adjacent_colors
+ 
+
+
+
+# # Test complementarty colors:
+# color = "#771958"
+# complementary = complementary_colors(color)
+# print(f"Original color: {color}")
+# print(f"Complementary color: {complementary}")
+
+# # Test adjacent colors:
+# print(f"Adjacent colors for {color}:")
+# colors = adjacent_colors(color)
+
+# # Test gradient colors:
+# print(f"Gradient colors between {colors[0]} and {colors[1]}:")
+# gradient = gradient_colors(colors[0], colors[1])
+# for color in gradient:
+#     print(color)

dominantColors.py

@@ -0,0 +1,89 @@
+#This file finds X dominant colors of a given image, using k-means and different channels of the image,
+#like RGB, and luminance.
+
+import colorsys
+import math
+import numpy as np
+from PIL import Image
+from sklearn.cluster import MiniBatchKMeans
+import compColors
+
+PALETTE_WIDTH = 800
+PALETTE_HEIGHT = 200
+MAX_SIZE = 500,500
+
+def make_palette(file, n_clusters):
+	im = Image.open(file)
+	im.thumbnail(MAX_SIZE)
+
+	pixels = np.array([im.getpixel((x,y)) for x in range(0, im.size[0]) for y in range(0, im.size[1])])
+	clt = MiniBatchKMeans(n_clusters = n_clusters, n_init = 1)
+	clt.fit(pixels)
+	return [[int(round(i)) for i in color] for color in clt.cluster_centers_]
+
+def perceived_brightness (r, g, b):
+	"""
+	Calculates perceived brightness for the given RGB values.
+	code from Darel Rex Finley (http://alienryderflex.com/hsp.html)
+	"""
+	return math.sqrt((.299 * r * r) + (.587 * g * g) + (.114 * b * b))
+
+def hsp_rank (r, g, b, mult=8):
+	"""
+	Combines hue, saturation, and perceived brightness info for a
+	smoother sort.
+	"""
+	lum = perceived_brightness(r, g, b)
+	h, s, v = colorsys.rgb_to_hsv(r, g, b)
+
+	return (h * lum * mult, s * lum * mult, s * mult)
+
+def findDominantColors(imageFile, numberOfColors, showImage = True):
+    src = imageFile
+    n_clusters = numberOfColors
+
+    cluster_centers = make_palette(src, n_clusters)
+    cluster_centers.sort(key=lambda rgb: hsp_rank(*rgb))
+
+    pixels = []
+    dominantColors = []
+    for i in range(n_clusters):
+        color = tuple(cluster_centers[i])
+        dominantColors.append(color)
+        # print("Color #{}: {}".format(i+1, color))
+        for j in range(PALETTE_WIDTH//n_clusters * PALETTE_HEIGHT):
+            pixels.append(color)
+    if showImage:
+        img = Image.new('RGB',(PALETTE_HEIGHT,PALETTE_WIDTH))
+        img.putdata(pixels) 
+        img.show()
+    return dominantColors
+	
+def rgb_to_hex(rgb):
+    return '#{:02x}{:02x}{:02x}'.format(rgb[0], rgb[1], rgb[2])
+
+def hex_to_rgb(hex):
+    hex = hex.lstrip('#')
+    return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4))
+
+def create_color_palette(colors, palette_width=800, palette_height=200):
+    """
+    Receives a list of colors in hex format and creates a palette image
+    """
+    pixels = []
+    n_colors = len(colors)
+    for i in range(n_colors):
+        color = hex_to_rgb(colors[i])
+        for j in range(palette_width//n_colors * palette_height):
+            pixels.append(color)
+    img = Image.new('RGB', (palette_height, palette_width))
+    img.putdata(pixels) 
+    img.show()
+
+
+##############pipeline for testing
+# print("Dominant colors:")
+# dominantColors=findDominantColors('./estampa-test.png', 10, False)
+# dominantColorHex=[rgb_to_hex(color) for color in dominantColors]
+# print(dominantColorHex)
+# # ['#d54b18', '#555015', '#98680e', '#1f3919', '#da8007', '#a50637', '#b50406', '#d52350', '#e2090f', '#f8545c']

recolorLinearColorTransfer.py

@@ -0,0 +1,79 @@
+# This script performs the linear color transfer step that 
+# leongatys/NeuralImageSynthesis' Scale Control code performs.
+# https://github.com/leongatys/NeuralImageSynthesis/blob/master/ExampleNotebooks/ScaleControl.ipynb
+# Standalone script by github.com/htoyryla, and github.com/ProGamerGov
+#based on this: https://github.com/ProGamerGov/Neural-Tools
+
+import numpy as np
+import argparse
+import imageio
+from skimage import io,transform,img_as_float
+from skimage.io import imread,imsave
+from PIL import Image
+from numpy import eye 
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-t', '--target_image', type=str, help="The image you are transfering color to. Ex: target.png", required=True)
+parser.add_argument('-s', '--source_image', type=str, help="The image you are transfering color from. Ex: source.png", required=True)
+parser.add_argument('-o', '--output_image', default='output.png', help="The name of your output image. Ex: output.png", type=str)
+parser.add_argument('-m', '--mode', default='pca', help="The color transfer mode. Options are pca, chol, or sym.", type=str)
+parser.add_argument('-e', '--eps', default='1e-5', help="Your epsilon value in scientific notation or normal notation. Ex: 1e-5 or 0.00001", type=float)
+parser.parse_args()
+args = parser.parse_args()
+
+
+Image.MAX_IMAGE_PIXELS = 1000000000 # Support gigapixel images
+
+
+def main():   
+
+    target_img = imageio.v2.imread(args.target_image, pilmode="RGB").astype(float)/256
+    source_img = imageio.v2.imread(args.source_image, pilmode="RGB").astype(float)/256
+    
+    output_img = match_color(target_img, source_img, mode=args.mode, eps=args.eps)
+    output_img = (output_img * 255).astype(np.uint8)
+    imsave(args.output_image, output_img)
+    # imsave(args.output_image, output_img)
+
+
+def match_color(target_img, source_img, mode='pca', eps=1e-5):
+    '''
+    Matches the colour distribution of the target image to that of the source image
+    using a linear transform.
+    Images are expected to be of form (w,h,c) and float in [0,1].
+    Modes are chol, pca or sym for different choices of basis.
+    '''
+    mu_t = target_img.mean(0).mean(0)
+    t = target_img - mu_t
+    t = t.transpose(2,0,1).reshape(3,-1)
+    Ct = t.dot(t.T) / t.shape[1] + eps * eye(t.shape[0])
+    mu_s = source_img.mean(0).mean(0)
+    s = source_img - mu_s
+    s = s.transpose(2,0,1).reshape(3,-1)
+    Cs = s.dot(s.T) / s.shape[1] + eps * eye(s.shape[0])
+    if mode == 'chol':
+        chol_t = np.linalg.cholesky(Ct)
+        chol_s = np.linalg.cholesky(Cs)
+        ts = chol_s.dot(np.linalg.inv(chol_t)).dot(t)
+    if mode == 'pca':
+        eva_t, eve_t = np.linalg.eigh(Ct)
+        Qt = eve_t.dot(np.sqrt(np.diag(eva_t))).dot(eve_t.T)
+        eva_s, eve_s = np.linalg.eigh(Cs)
+        Qs = eve_s.dot(np.sqrt(np.diag(eva_s))).dot(eve_s.T)
+        ts = Qs.dot(np.linalg.inv(Qt)).dot(t)
+    if mode == 'sym':
+        eva_t, eve_t = np.linalg.eigh(Ct)
+        Qt = eve_t.dot(np.sqrt(np.diag(eva_t))).dot(eve_t.T)
+        Qt_Cs_Qt = Qt.dot(Cs).dot(Qt)
+        eva_QtCsQt, eve_QtCsQt = np.linalg.eigh(Qt_Cs_Qt)
+        QtCsQt = eve_QtCsQt.dot(np.sqrt(np.diag(eva_QtCsQt))).dot(eve_QtCsQt.T)
+        ts = np.linalg.inv(Qt).dot(QtCsQt).dot(np.linalg.inv(Qt)).dot(t)
+    matched_img = ts.reshape(*target_img.transpose(2,0,1).shape).transpose(1,2,0)
+    matched_img += mu_s
+    matched_img[matched_img>1] = 1
+    matched_img[matched_img<0] = 0
+    return matched_img
+
+
+if __name__ == "__main__":
+    main()

recolorLumaConverterAlgo.py

@@ -0,0 +1,63 @@
+from PIL import Image
+
+def hex_to_rgb(value):
+    value = value.lstrip('#')
+    length = len(value)
+    return tuple(int(value[i:i + length // 3], 16) for i in range(0, length, length // 3))
+
+def luminance(color):
+    # Use the ITU-R BT.709 formula
+    r, g, b = color
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+# def interpolate_color(color1, color2, factor):
+#     return tuple(int(c1 * (1 - factor) + c2 * factor) for c1, c2 in zip(color1, color2))
+
+def quadratic_interpolate(factor):
+    #make the interpolation closer to the second color
+    return factor ** 2
+
+def interpolate_color(color1, color2, factor):
+    adjusted_factor = quadratic_interpolate(factor)
+    return tuple(int(c1 * (1 - adjusted_factor) + c2 * adjusted_factor) for c1, c2 in zip(color1, color2))
+
+
+def remap_image_colors(image_path, hex_palette):
+    # img = Image.open(image_path)
+    img = Image.fromarray(image_path)
+
+    rgb_palette = [hex_to_rgb(hex_code) for hex_code in hex_palette]
+
+    sorted_palette = sorted(rgb_palette, key=luminance)
+
+    img_rgb = img.convert("RGB")
+    pixels = img_rgb.load()
+
+    for y in range(img.height):
+        for x in range(img.width):
+            original_color = pixels[x, y]
+            lum = luminance(original_color)
+
+            # Find the closest palette colors by luminance (one darker, one brighter)
+            prev_color = sorted_palette[0]
+            next_color = sorted_palette[-1]
+            for i in range(1, len(sorted_palette)):
+                if luminance(sorted_palette[i]) > lum:
+                    next_color = sorted_palette[i]
+                    prev_color = sorted_palette[i-1]
+                    break
+
+            # Interpolate between the two closest colors
+            lum_range = luminance(next_color) - luminance(prev_color)
+            if lum_range == 0:
+                mapped_color = prev_color
+            else:
+                factor = (lum - luminance(prev_color)) / lum_range
+                mapped_color = interpolate_color(prev_color, next_color, factor)
+
+            pixels[x, y] = mapped_color
+
+    img_rgb.save("result.jpg")
+
+# hex_palette = ['#db5a1e', '#555115', '#9a690e', '#1f3a19', '#da8007', '#9a0633', '#b70406', '#d01b4b', '#e20b0f', '#f7515d']
+# remap_image_colors('estampa.jpg', hex_palette)

recolorOTAlgo.py

@@ -0,0 +1,97 @@
+import numpy as np
+import cv2
+import ot
+from PIL import Image
+
+def transfer_channel(source_channel, target_channel):
+    source_hist, _ = np.histogram(source_channel, bins=256, range=(0, 256))
+    target_hist, _ = np.histogram(target_channel, bins=256, range=(0, 256))
+
+    source_hist = source_hist.astype(np.float64) / source_hist.sum()
+    target_hist = target_hist.astype(np.float64) / target_hist.sum()
+
+    r = np.arange(256).reshape((-1, 1))
+    c = np.arange(256).reshape((1, -1))
+    M = (r - c) ** 2
+    M = M / M.max()
+
+    P = ot.emd(source_hist, target_hist, M)
+    
+    transferred_channel = np.zeros_like(source_channel)
+    for i in range(256):
+        transferred_channel[source_channel == i] = P[i].argmax()
+
+    return transferred_channel
+
+def optimal_transport_color_transfer(source, target):
+    source_lab = cv2.cvtColor(source, cv2.COLOR_BGR2Lab).astype(np.float64)
+    target_lab = cv2.cvtColor(target, cv2.COLOR_BGR2Lab).astype(np.float64)
+
+    # Transfer all channels L, a, and b
+    for ch in range(3):
+        source_lab[:, :, ch] = transfer_channel(source_lab[:, :, ch], target_lab[:, :, ch])
+
+    transferred_rgb = cv2.cvtColor(source_lab.astype(np.uint8), cv2.COLOR_Lab2BGR)
+    return transferred_rgb
+    
+
+def rgb_to_hex(rgb):
+    return '#{:02x}{:02x}{:02x}'.format(rgb[0], rgb[1], rgb[2])
+
+def hex_to_rgb(hex):
+    hex = hex.lstrip('#')
+    return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4))
+
+
+def create_color_palette(colors, palette_width=800, palette_height=200):
+    """
+    Receives a list of colors in hex format and creates a palette image
+    """
+    pixels = []
+    n_colors = len(colors)
+    for i in range(n_colors):
+        color = hex_to_rgb(colors[i])
+        for j in range(palette_width//n_colors * palette_height):
+            pixels.append(color)
+    img = Image.new('RGB', (palette_height, palette_width))
+    img.putdata(pixels) 
+    # img.show()
+    return img
+
+
+# if __name__ == "__main__":
+#     source = cv2.imread("estampa-test.png")
+#     target = cv2.imread("color.png")
+#     transferred = optimal_transport_color_transfer(source, target)
+
+#     smooth = False#test with true to have a different result.
+#     if smooth:
+#         # Apply bilateral filtering
+#         diameter = 30  # diameter of each pixel neighborhood, adjust based on your image size
+#         sigma_color = 25  # larger value means colors farther to each other will mix together
+#         sigma_space = 25  # larger values means farther pixels will influence each other if their colors are close enough
+#         smoothed = cv2.bilateralFilter(transferred, diameter, sigma_color, sigma_space)
+#         cv2.imwrite("result_OTA.jpg", smoothed)
+#     else:
+#         cv2.imwrite("result_OTA.jpg", transferred)
+
+
+def recolor(source, colors):
+    pallete_img = create_color_palette(colors)
+    palette_bgr = cv2.cvtColor(np.array(pallete_img), cv2.COLOR_RGB2BGR)
+    recolored = optimal_transport_color_transfer(source, palette_bgr)
+    smooth = True#test with true for different results.
+    if smooth:
+        # Apply bilateral filtering
+        diameter = 10  # diameter of each pixel neighborhood, adjust based on your image size
+        sigma_color = 25  # larger value means colors farther to each other will mix together
+        sigma_space = 15  # larger values means farther pixels will influence each other if their colors are close enough
+        smoothed = cv2.bilateralFilter(recolored, diameter, sigma_color, sigma_space)
+        recoloredFile = cv2.imwrite("result.jpg", smoothed, [cv2.IMWRITE_JPEG_QUALITY, 100])
+        return recoloredFile
+    else:
+        recoloredFile = cv2.imwrite("result.jpg", recolored)
+        return recoloredFile
+
+
+

recolorPaletteBasedTransfer.py

@@ -0,0 +1,115 @@
+#https://gfx.cs.princeton.edu/pubs/Chang_2015_PPR/index.php
+import numpy as np
+import cv2
+from sklearn.cluster import KMeans
+from PIL import Image
+
+def extract_palette(image, n_colors=5):
+    """
+    Extracts dominant colors from the image using KMeans clustering.
+    
+    Parameters:
+    - image: np.array, the input image
+    - n_colors: int, the number of colors to extract
+    
+    Returns:
+    - palette: list, dominant colors in the image
+    """
+    # Reshape the image to be a list of pixels
+    pixels = image.reshape(-1, 3)
+    
+    # Apply KMeans clustering to find the most dominant colors
+    kmeans = KMeans(n_clusters=n_colors)
+    kmeans.fit(pixels)
+    
+    # Get the RGB values of the clusters' centers
+    palette = kmeans.cluster_centers_
+    
+    return palette
+
+def map_colors(source_img, source_palette, target_palette):
+    """
+    Maps colors from the source palette to the target palette.
+    
+    Parameters:
+    - source_img: np.array, the source image
+    - source_palette: list, the source color palette
+    - target_palette: list, the target color palette
+    
+    Returns:
+    - recolored_img: np.array, the recolored image
+    """
+    recolored_img = np.copy(source_img)
+    
+    for i in range(source_img.shape[0]):
+        for j in range(source_img.shape[1]):
+            # Find the nearest color in the source palette
+            distances = np.linalg.norm(source_palette - source_img[i, j], axis=1)
+            closest_idx = np.argmin(distances)
+            
+            # Replace with the corresponding color from the target palette
+            recolored_img[i, j] = target_palette[closest_idx]
+            
+    return recolored_img
+
+def palette_based_color_transfer(source_img, target_palette, n_colors=5):
+    """
+    Performs palette based color transfer.
+    
+    Parameters:
+    - source_img: np.array, the source image
+    - target_palette: list, the target color palette
+    - n_colors: int, the number of colors in the source palette (default is 5)
+    
+    Returns:
+    - recolored_img: np.array, the recolored image
+    """
+    # Convert the source image to RGB
+    source_img = cv2.cvtColor(source_img, cv2.COLOR_BGR2RGB)
+    
+    # Extract the source palette
+    source_palette = extract_palette(source_img, n_colors)
+    
+    # Perform color mapping
+    recolored_img = map_colors(source_img, source_palette, target_palette)
+    
+    return recolored_img
+
+def create_color_palette(colors, palette_width=800, palette_height=200):
+    """
+    Receives a list of colors in hex format and creates a palette image
+    """
+    pixels = []
+    n_colors = len(colors)
+    for i in range(n_colors):
+        color = hex_to_rgb(colors[i])
+        for j in range(palette_width//n_colors * palette_height):
+            pixels.append(tuple(color))  # Convert color to tuple
+    img = Image.new('RGB', (palette_height, palette_width))
+    img.putdata(pixels) 
+    # img.show()
+    return img
+
+def hex_to_rgb(hex_color):
+    return [int(hex_color[i:i+2], 16) for i in (1, 3, 5)]
+# Example usage:
+# source_img_path = "estampa.jpg"
+# # target_palette = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0], [0, 255, 255]]
+# hex_colors = ["#db5a1e", "#555115", "#9a690e", "#1f3a19", "#da8007", "#9a0633", "#b70406", "#d01b4b", "#e20b0f", "#f7515d"]
+
+# target_palette = [hex_to_rgb(color) for color in hex_colors]
+# recolored_img = palette_based_color_transfer(source_img_path, target_palette, 10)
+# cv2.imwrite("recolored_image.jpg", cv2.cvtColor(recolored_img, cv2.COLOR_RGB2BGR))
+
+def recolor(source, colors):
+    palette_img = create_color_palette(colors)
+    palette_bgr = cv2.cvtColor(np.array(palette_img), cv2.COLOR_RGB2BGR)
+    
+    target_palette = [hex_to_rgb(color) for color in colors]
+    source_bgr = cv2.cvtColor(source, cv2.COLOR_RGB2BGR)
+    # No need to convert source to BGR, assume it's already in RGB
+    recolored = palette_based_color_transfer(source_bgr, target_palette, 10)
+    cv2.imwrite("result.jpg", cv2.cvtColor(recolored, cv2.COLOR_RGB2BGR))
+    return recolored
+
+

recolorReinhardAlgo.py

@@ -0,0 +1,89 @@
+import cv2
+import numpy as np
+from PIL import Image
+
+def reinhards_color_transfer(source, target):
+    # Convert the images from the RGB to the Lab color space
+    source_lab = cv2.cvtColor(source, cv2.COLOR_BGR2Lab).astype(np.float64)
+    target_lab = cv2.cvtColor(target, cv2.COLOR_BGR2Lab).astype(np.float64)
+    
+    # Compute mean and standard deviation for each channel in both images
+    l_mean_src, l_std_src = np.mean(source_lab[:, :, 0]), np.std(source_lab[:, :, 0])
+    a_mean_src, a_std_src = np.mean(source_lab[:, :, 1]), np.std(source_lab[:, :, 1])
+    b_mean_src, b_std_src = np.mean(source_lab[:, :, 2]), np.std(source_lab[:, :, 2])
+
+    l_mean_tar, l_std_tar = np.mean(target_lab[:, :, 0]), np.std(target_lab[:, :, 0])
+    a_mean_tar, a_std_tar = np.mean(target_lab[:, :, 1]), np.std(target_lab[:, :, 1])
+    b_mean_tar, b_std_tar = np.mean(target_lab[:, :, 2]), np.std(target_lab[:, :, 2])
+    
+    # Subtract the means from the source image
+    source_lab[:, :, 0] -= l_mean_src
+    source_lab[:, :, 1] -= a_mean_src
+    source_lab[:, :, 2] -= b_mean_src
+
+    # Scale by the standard deviations
+    source_lab[:, :, 0] = (l_std_tar / l_std_src) * source_lab[:, :, 0]
+    source_lab[:, :, 1] = (a_std_tar / a_std_src) * source_lab[:, :, 1]
+    source_lab[:, :, 2] = (b_std_tar / b_std_src) * source_lab[:, :, 2]
+
+    # Add the target means
+    source_lab[:, :, 0] += l_mean_tar
+    source_lab[:, :, 1] += a_mean_tar
+    source_lab[:, :, 2] += b_mean_tar
+    
+    # Clip pixel values to ensure they fall within the valid Lab range
+    source_lab[:, :, 0] = np.clip(source_lab[:, :, 0], 0, 255)
+    source_lab[:, :, 1] = np.clip(source_lab[:, :, 1], 0, 255)
+    source_lab[:, :, 2] = np.clip(source_lab[:, :, 2], 0, 255)
+    
+    # Convert back to RGB
+    transferred_rgb = cv2.cvtColor(source_lab.astype(np.uint8), cv2.COLOR_Lab2BGR)
+    return transferred_rgb
+
+def rgb_to_hex(rgb):
+    return '#{:02x}{:02x}{:02x}'.format(rgb[0], rgb[1], rgb[2])
+
+def hex_to_rgb(hex):
+    hex = hex.lstrip('#')
+    return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4))
+
+def create_color_palette(colors, palette_width=800, palette_height=200):
+    """
+    Receives a list of colors in hex format and creates a palette image
+    """
+    pixels = []
+    n_colors = len(colors)
+    for i in range(n_colors):
+        color = hex_to_rgb(colors[i])
+        for j in range(palette_width//n_colors * palette_height):
+            pixels.append(color)
+    img = Image.new('RGB', (palette_height, palette_width))
+    img.putdata(pixels) 
+    # img.show()
+    return img
+
+
+# if __name__ == "__main__":
+#     source = cv2.imread("estampa.jpg")  
+#     colors = ['#6b3d68', '#6d2055', '#695977', '#6b7988', '#6f9b9b']
+#     # Generate palette image
+#     palette_img = create_color_palette(colors)
+#     # Convert the palette image to BGR format
+#     palette_bgr = cv2.cvtColor(np.array(palette_img), cv2.COLOR_RGB2BGR)
+    
+#     # Save the palette image
+#     # cv2.imwrite("palette.jpg", palette_bgr)
+    
+#     target = palette_bgr#cv2.imread("palette.jpg")
+
+#     transferred = reinhards_color_transfer(source, target)
+#     cv2.imwrite("transferred_reinhard.jpg", transferred) 
+
+
+def recolor(source, colors):
+    palette_img = create_color_palette(colors)
+    palette_bgr = cv2.cvtColor(np.array(palette_img), cv2.COLOR_RGB2BGR)
+
+    recolored = reinhards_color_transfer(source, palette_bgr)
+    recoloredFile = cv2.imwrite("result.jpg", recolored) 
+    return recolored

recolorReinhardV2Algo.py

@@ -0,0 +1,48 @@
+import cv2
+import numpy as np
+
+def color_transfer(source, target):
+    # Convert the images from RGB to L*a*b* color space
+    source_lab = cv2.cvtColor(source, cv2.COLOR_BGR2Lab)
+    target_lab = cv2.cvtColor(target, cv2.COLOR_BGR2Lab)
+    
+    # Split the LAB image into L, A and B channels
+    source_l, source_a, source_b = cv2.split(source_lab)
+    target_l, target_a, target_b = cv2.split(target_lab)
+    
+    # Compute mean and standard deviation for each channel in both images
+    l_mean_src, l_std_src, = source_l.mean(), source_l.std()
+    a_mean_src, a_std_src = source_a.mean(), source_a.std()
+    b_mean_src, b_std_src = source_b.mean(), source_b.std()
+
+    l_mean_tar, l_std_tar = target_l.mean(), target_l.std()
+    a_mean_tar, a_std_tar = target_a.mean(), target_a.std()
+    b_mean_tar, b_std_tar = target_b.mean(), target_b.std()
+    
+    # Perform the color transfer
+    l_result = (source_l - l_mean_src) * (l_std_tar / l_std_src) + l_mean_tar
+    a_result = (source_a - a_mean_src) * (a_std_tar / a_std_src) + a_mean_tar
+    b_result = (source_b - b_mean_src) * (b_std_tar / b_std_src) + b_mean_tar
+    
+    # Clip and reshape the channels
+    l_result = np.clip(l_result, 0, 255).astype(np.uint8)
+    a_result = np.clip(a_result, 0, 255).astype(np.uint8)
+    b_result = np.clip(b_result, 0, 255).astype(np.uint8)
+    
+    # Merge the channels back
+    result_lab = cv2.merge([l_result, a_result, b_result])
+    
+    # Convert the resulting image from L*a*b* to RGB color space
+    result = cv2.cvtColor(result_lab, cv2.COLOR_Lab2BGR)
+    
+    return result
+
+# Load source and target images
+source_img = cv2.imread("estampa.jpg")
+target_img = cv2.imread("cor.jpg")
+
+# Perform color transfer
+transferred_img = color_transfer(source_img, target_img)
+
+# Return the transferred image for visualization
+cv2.imwrite("result.jpg", transferred_img)

recolorTransferAlgo.py

@@ -0,0 +1,70 @@
+import numpy as np
+import cv2
+from PIL import Image
+
+def read_file(source_image, target_image):
+    s = cv2.cvtColor(source_image, cv2.COLOR_RGB2LAB)
+    t = cv2.cvtColor(np.array(target_image), cv2.COLOR_RGB2LAB)
+    return s, t
+
+def get_mean_and_std(x):
+    x_mean, x_std = cv2.meanStdDev(x)
+    x_mean = np.hstack(np.around(x_mean,2))
+    x_std = np.hstack(np.around(x_std,2))
+    return x_mean, x_std
+
+def color_transfer(source, target_image):
+    """
+    The primary goal of this algorithm is to adjust the colors of the source image
+    such that its color distribution looks like the distribution of the target image.
+    """
+    s, t = read_file(source, target_image)
+    s_mean, s_std = get_mean_and_std(s)
+    t_mean, t_std = get_mean_and_std(t)
+    height, width, channel = s.shape
+    for i in range(0,height):
+        for j in range(0,width):
+            for k in range(0,channel):
+                x = s[i,j,k]
+                x = ((x-s_mean[k])*(t_std[k]/s_std[k]))+t_mean[k]
+                # round or +0.5
+                x = round(x)
+                # boundary check
+                x = 0 if x<0 else x
+                x = 255 if x>255 else x
+                s[i,j,k] = x
+    s = cv2.cvtColor(s,cv2.COLOR_LAB2BGR)
+    cv2.imwrite('result.jpg',s)
+
+def rgb_to_hex(rgb):
+    return '#{:02x}{:02x}{:02x}'.format(rgb[0], rgb[1], rgb[2])
+
+def hex_to_rgb(hex):
+    hex = hex.lstrip('#')
+    return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4))
+
+def create_color_palette(colors, palette_width=800, palette_height=200):
+    """
+    Receives a list of colors in hex format and creates a palette image
+    """
+    pixels = []
+    n_colors = len(colors)
+    for i in range(n_colors):
+        color = hex_to_rgb(colors[i])
+        for j in range(palette_width//n_colors * palette_height):
+            pixels.append(color)
+    img = Image.new('RGB', (palette_height, palette_width))
+    img.putdata(pixels) 
+    # img.show()
+    return img
+
+# colors = ['#d54b18', '#555015', '#98680e', '#1f3919', '#da8007', '#a50637', '#b50406', '#d52350', '#e2090f', '#f8545c']
+# img = create_color_palette(colors)
+# color_transfer('s2', img)
+
+def recolor(source, colors):
+    palette_img = create_color_palette(colors)
+    palette_bgr = cv2.cvtColor(np.array(palette_img), cv2.COLOR_RGB2BGR)
+    source_bgr = cv2.cvtColor(source, cv2.COLOR_RGB2BGR)
+    recolored = color_transfer(source_bgr, palette_bgr)
+    return recolored

requirements.txt

@@ -0,0 +1,47 @@
+annotated-types==0.5.0
+anyio==3.7.1
+certifi==2023.7.22
+click==8.1.7
+dnspython==2.4.2
+email-validator==2.0.0.post2
+exceptiongroup==1.1.3
+fastapi==0.101.1
+h11==0.14.0
+httpcore==0.17.3
+httptools==0.6.0
+httpx==0.24.1
+idna==3.4
+imageio==2.31.1
+itsdangerous==2.1.2
+Jinja2==3.1.2
+joblib==1.3.2
+lazy_loader==0.3
+MarkupSafe==2.1.3
+networkx==3.1
+numpy==1.25.2
+opencv-python==4.8.0.76
+orjson==3.9.5
+packaging==23.1
+Pillow==10.0.0
+POT==0.9.1
+pydantic==2.2.1
+pydantic-extra-types==2.0.0
+pydantic-settings==2.0.3
+pydantic_core==2.6.1
+python-dotenv==1.0.0
+python-multipart==0.0.6
+PyWavelets==1.4.1
+PyYAML==6.0.1
+scikit-image==0.21.0
+scikit-learn==1.3.0
+scipy==1.11.2
+sniffio==1.3.0
+starlette==0.27.0
+threadpoolctl==3.2.0
+tifffile==2023.8.12
+typing_extensions==4.7.1
+ujson==5.8.0
+uvicorn==0.23.2
+uvloop==0.17.0
+watchfiles==0.19.0
+websockets==11.0.3

server.py

@@ -0,0 +1,113 @@
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+import io
+from PIL import Image, ImageOps
+import numpy as np
+import compColors
+import dominantColors
+import recolorReinhardAlgo
+import recolorOTAlgo
+import recolorTransferAlgo
+import recolorLumaConverterAlgo
+import recolorPaletteBasedTransfer
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+@app.post("/dominantColor/")
+async def dominant_color(file: UploadFile = File(...), num_colors: int = Form(...)):
+    """
+    Receive an image file and an integer and return the dominant color(s).
+    """
+    file_content = await file.read()
+    image_bytes = io.BytesIO(file_content)
+    im = Image.open(image_bytes)
+    dominantColorsRGB = dominantColors.findDominantColors(image_bytes, num_colors, False)
+    dominantColorsHex = [dominantColors.rgb_to_hex(color) for color in dominantColorsRGB]
+    return {"dominantColors": dominantColorsHex}
+
+@app.post("/ColorPalettes/")
+async def color_palettes(colors: str = Form(...)):
+    """
+    Receive an array of strings representing colors and return a color palette based on these colors.
+    """
+    #maybe this isn't necessary. converting the string to an array of strings
+    colors = [color.strip() for color in colors.split(',')]
+    #generate the first pallete, which is the complementary colors of the given colors
+    complementaryColors = []
+    for color in colors:
+        complementaryColors.append(compColors.complementary_colors(color))
+
+    #generate the second palette using the adjacent colors algorithm:
+    adjacentColors = []
+    for color in colors:
+        _adjcolors = compColors.adjacent_colors(color)
+        for _color in _adjcolors:
+            if _color not in adjacentColors:
+                adjacentColors.append(_color)
+    #generate the third palette using the gradient colors algorithm:
+    gradientColors = []
+    for i in range(len(colors)-1):
+        gradientColors.append(compColors.gradient_colors(colors[i], colors[i+1]))
+
+    #Fixing size of palletes to 5 colors:
+    complementaryColors = [complementaryColors[i:i + 5] for i in range(0, len(complementaryColors), 5)]
+    adjacentColors = [adjacentColors[i:i + 5] for i in range(0, len(adjacentColors), 5)]
+    colors = [colors[i:i + 5] for i in range(0, len(colors), 5)]
+    
+    return {"inputColor": colors, "complementaryColors": complementaryColors, "adjacentColors": adjacentColors, "gradientColors": gradientColors}
+
+@app.post("/recolor/")
+async def recolor(file: UploadFile = File(...), colors: str = Form(...),  model: str = Form(...)):
+    """
+    Receive an image file and an array of strings representing colors of a selected pallete and recolor an image.
+    """
+    method = model
+    invertColors = False
+    colors = [color.strip() for color in colors.split(',')]
+    file_content = await file.read()
+    image_bytes = io.BytesIO(file_content)
+    image = Image.open(image_bytes)
+    if invertColors:
+        image = ImageOps.invert(image)
+    image_np = np.array(image)
+
+    if method == "CCA":
+        #Characteristic Color Analysis
+        recolorReinhardAlgo.recolor(image_np, colors)
+    elif method == "OTA":
+        #Optimal Transport Algorithm transfer
+        recolorOTAlgo.recolor(image_np, colors)
+    elif method =="KMEANS":
+        #K-means clustering transfer
+        recolorTransferAlgo.recolor(image_np, colors)
+    elif method == "LUMA":
+        #Luma converter transfer
+        recolorLumaConverterAlgo.remap_image_colors(image_np, colors)
+    elif method == "palette":
+        #palette transfer
+        recolorPaletteBasedTransfer.recolor(image_np, colors)
+    img_file = open("./result.jpg", "rb")
+    return StreamingResponse(img_file, media_type="image/jpeg")
+
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+
+
+#how to run:
+#source env/bin/activate     
+#uvicorn server:app --reload

todo.md

@@ -0,0 +1,15 @@
+* add more two funcoes de troca de cor
+*add invert colors
+*check file type
+*mask
+
+**added:
+recolor palette based transfer, recolor reinhard v2 and recolor linear transfer. => need to add to the backend.
+
+`
+source ./env/bin/activate
+`
+#how to run:
+#source env/bin/activate     
+#uvicorn server:app --reload
+`