Add files via upload

Author: JopdeBoo

linCC.py

@@ -0,0 +1,66 @@
+import numpy as np
+import colour
+import cv2
+import matplotlib.pyplot as plt
+import linConversions as conv
+import os
+from PIL import Image
+
+def sRGB_to_lin(rgb):
+    # Converts array or list of sRGB values to linear RGB values
+    rgb = np.array(rgb)/255
+    linear = np.where(rgb<=0.04045, rgb/12.92, ((rgb+0.055)/1.055)**(2.4))
+    return((linear*255).astype(np.uint8))
+
+def ColourCorrect(image_lin, corrected_img_lin, corrected_img_sRGB, source_lin,
+                  reference_RGB, terms):
+    
+    # Load in reference data and convert to linear RGB
+    reference_RGB = np.loadtxt(reference_RGB, delimiter=",",
+                               skiprows=1, usecols=(0, 1, 2))
+    reference_lin = conv.sRGB_to_lin(reference_RGB)
+    
+    # Calculating the colour correction matrix and colour correcting the image
+    # using the reference and source colour values
+    CCM, colour_corrected=colour.characterisation.colour_correction_Cheung2004(
+        image_lin, source_lin, reference_lin, terms)
+    colour_corrected = colour_corrected.astype(int).clip(0,255)
+    
+    # Converting the linear images to sRGB
+    image_sRGB = conv.lin_to_sRGB(image_lin)
+    corrected_sRGB = conv.lin_to_sRGB(colour_corrected)
+    
+    # Plotting all images
+    plt.imshow(image_lin)
+    plt.title("Source linear")
+    plt.show()
+    
+    plt.imshow(colour_corrected)
+    plt.title("Corrected linear")
+    plt.show()
+        
+    plt.imshow(image_sRGB)
+    plt.title("Source sRGB")
+    plt.show()
+    
+    plt.imshow(corrected_sRGB)
+    plt.title("Corrected sRGB")
+    plt.show()
+    
+    # Saving corrected images (cv2 works in BGR, so R and B are swapped)
+    corrected_img_BGR_lin = colour_corrected[:,:,::-1]
+    corrected_img_BGR_sRGB = corrected_sRGB[:,:,::-1]
+    cv2.imwrite(corrected_img_lin, corrected_img_BGR_lin)
+    cv2.imwrite(corrected_img_sRGB, corrected_img_BGR_sRGB)
+    return(colour_corrected, reference_lin, CCM)
+
+def BatchCorrect(map_path, checker_source_lin, checker_reference_sRGB, terms,
+                 corrected_dir):
+    os.makedirs(corrected_dir)
+    for image in sorted(os.listdir(map_path)):
+        if image.endswith(".jpg") or image.endswith(".png"):
+            image_name = image.replace(".jpg","")
+            image_lin = sRGB_to_lin(Image.open(map_path+"/"+image))
+            ColourCorrect(image_lin, corrected_dir+"/"+image_name+"_cor_lin.jpg", 
+                          corrected_dir+"/"+image_name+"_cor_sRGB.jpg", 
+                          checker_source_lin, checker_reference_sRGB, terms)

linConversions.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+def sRGB_to_lin(rgb):
+    # Converts array or list of sRGB values to linear RGB values
+    rgb = np.array(rgb)/255
+    linear = np.where(rgb<=0.04045, rgb/12.92, ((rgb+0.055)/1.055)**(2.4))
+    return((linear*255).astype(int))
+
+def lin_to_XYZ(lin):
+    # Converts array of linear RGB values to XYZ values
+    lin = np.array(lin)/255
+    M = np.array([[0.4124, 0.3576, 0.1805],
+                  [0.2126, 0.7152, 0.0722],
+                  [0.0193, 0.1192, 0.9505]])
+    return(np.transpose(np.matmul(M, np.transpose(lin))))
+
+def lin_to_sRGB(lin):
+    # Converts array or list of linear RGB values to sRGB values
+    lin = np.array(lin)/255
+    rgb = np.where(lin <= 0.0031308, 12.92*lin, (1.055*lin)**(1/2.4)-0.055)
+    return((rgb*255).astype(int))
+
+def sRGB_to_XYZ(rgb):
+    # Converts array of sRGB values to XYZ values
+    rgb = rgb/255
+    linear = np.where(rgb<=0.04045, rgb/12.92, ((rgb+0.055)/1.055)**2.4)
+    M = np.array([[0.4124, 0.3576, 0.1805],
+                  [0.2126, 0.7152, 0.0722],
+                  [0.0193, 0.1192, 0.9505]])
+    return(np.transpose(np.matmul(M, np.transpose(linear))))

linDiffPlots.py

@@ -0,0 +1,112 @@
+import numpy as np
+import csv
+import matplotlib.pyplot as plt
+import colour.models as cm
+import skimage.color as sc
+import linConversions as conv
+
+SMALL_SIZE = 10*2                                        
+MEDIUM_SIZE = 12*2
+BIGGER_SIZE = 14*2
+
+plt.rcParams.update({"text.usetex": True,"font.family": "serif",
+                     "font.serif": ["Palatino"]})        # controls default text sizes
+plt.rc('axes', titlesize=MEDIUM_SIZE)                    # fontsize of the axes title
+plt.rc('axes', labelsize=MEDIUM_SIZE)                    # fontsize of the x and y labels
+plt.rc('xtick', labelsize=SMALL_SIZE, direction='in')    # fontsize of the tick labels
+plt.rc('ytick', labelsize=SMALL_SIZE, direction='in')    # fontsize of the tick labels
+plt.rc('legend', fontsize=SMALL_SIZE)                    # legend fontsize
+plt.rc('figure', figsize='15, 6')                        # size of the figure, used to be '4, 3' in inches
+
+def diffPlot(source_lin, reference_lin, corrected_lin):    
+    source_XYZ = conv.lin_to_XYZ(source_lin)
+    reference_XYZ = conv.lin_to_XYZ(reference_lin)
+    corrected_XYZ = conv.lin_to_XYZ(corrected_lin)
+    
+    source_Lab = sc.xyz2lab(source_XYZ)
+    reference_Lab = sc.xyz2lab(reference_XYZ)
+    corrected_Lab = sc.xyz2lab(corrected_XYZ)
+    
+    dE00_source = sc.deltaE_ciede2000(source_Lab, reference_Lab)
+    dE00_corrected = sc.deltaE_ciede2000(corrected_Lab, reference_Lab)
+            
+    diff_source_XYZ = np.sqrt(np.sum((source_XYZ - reference_XYZ)**2, axis=1))*100
+    diff_corrected_XYZ = np.sqrt(np.sum((corrected_XYZ - reference_XYZ)**2, axis=1))*100
+    
+    diff_source_lin = np.sqrt(np.sum((np.array(source_lin)/255 - np.array(reference_lin)/255)**2, axis=1))*100
+    diff_corrected_lin = np.sqrt(np.sum((np.array(corrected_lin)/255 - np.array(reference_lin)/255)**2, axis=1))*100                           
+    
+    x = np.arange(len(diff_source_XYZ))+1
+    width = 0.4
+    
+    plt.figure()
+    source_bar_XYZ = plt.bar(x - width/2, diff_source_XYZ, width, label='Source')
+    corrected_bar_XYZ = plt.bar(x + width/2, diff_corrected_XYZ, width, label='Corrected')
+    plt.title("Colour distance in XYZ-space")
+    plt.xlabel("Patch")
+    plt.ylabel("Distance")
+    plt.ylim([0,np.max(np.concatenate([diff_source_XYZ,diff_corrected_XYZ]))+5])
+    plt.vlines(np.arange(5.5, len(diff_source_XYZ),6),0,140, color="red")
+    plt.legend()
+    plt.show()
+    
+    plt.figure()
+    source_bar_RGB = plt.bar(x - width/2, diff_source_lin, width, label='Source')
+    corrected_bar_RGB = plt.bar(x + width/2, diff_corrected_lin, width, label='Corrected')
+    plt.title("Colour distance in RGB-space")
+    plt.xlabel("Patch")
+    plt.ylabel("Distance")
+    plt.ylim([0,np.max(np.concatenate([diff_source_lin,diff_corrected_lin]))+5])
+    print()
+    plt.vlines(np.arange(5.5, len(diff_source_lin),6),0,140, color="red")
+    plt.legend()
+    plt.show()
+    
+    plt.figure()
+    source_bar_dE = plt.bar(x - width/2, dE00_source, width, label='Source')
+    corrected_bar_dE = plt.bar(x + width/2, dE00_corrected, width, label='Corrected')
+    plt.title("Colour difference in dE00")
+    plt.xlabel("Patch")
+    plt.ylabel("dE00")
+    plt.xticks(np.arange(1,30.5,1))
+    plt.vlines(np.arange(0.5, len(dE00_corrected)+0.6,6),0,140, color="red")
+    plt.ylim([0,np.max(np.concatenate([dE00_source,dE00_corrected]))+5])
+    plt.xlim(0.5,30.5)
+    plt.legend()
+    plt.savefig(r"figures\dE00.pdf")
+    plt.show()
+    
+    source_err_XYZ = np.mean(diff_source_XYZ)
+    corrected_err_XYZ =np.mean(diff_corrected_XYZ)
+    
+    source_err_lin = np.mean(diff_source_lin)
+    corrected_err_lin =np.mean(diff_corrected_lin)
+    
+    dE00_source_avg = np.mean(dE00_source)
+    dE00_corrected_avg = np.mean(dE00_corrected)
+    return(source_err_XYZ,corrected_err_XYZ, source_err_lin,corrected_err_lin,dE00_source_avg,dE00_corrected_avg)
+
+def diffChart(reference_lin, corrected_lin, source_lin):
+    ref_sRGB = conv.lin_to_sRGB(reference_lin)
+    cor_sRGB = conv.lin_to_sRGB(corrected_lin)
+    sou_sRGB = conv.lin_to_sRGB(source_lin)
+    
+    colours2 = np.array([ref_sRGB,cor_sRGB])
+    colours1 = np.array([ref_sRGB,sou_sRGB])
+    
+    fig, axs = plt.subplots(nrows=2, sharex=True, figsize=(15,4))
+    axs[0].set_title('Colour comparisons')
+    axs[0].imshow(colours1)
+    axs[0].set_yticks([0,1])
+    axs[0].set_yticklabels(["reference","source"])
+    
+    #axs[1].set_title('blue should be down')
+    axs[1].imshow(colours2)
+    axs[1].set_yticks([0,1])
+    axs[1].set_yticklabels(["reference","corrected"])
+    
+    plt.xticks(np.arange(0,29.5,1),np.arange(1,30.5,1,dtype=int))
+    plt.xlabel("Patch number")
+    plt.savefig(r"figures\difference_visualised.pdf")
+    plt.show()
+

linMain.py

@@ -0,0 +1,108 @@
+import linMask as m
+import linCC as CC
+import linDiffPlots as dP
+
+
+if __name__ == "__main__":
+    # Put in file names:
+    # Image with colour checker
+    img_path = r"img\src1.jpg" 
+    # csv files in which data from image for squares of checker will be stored             
+    source_XYZ_csv = r"data\src1XYZ.csv"       
+    source_lin_csv = r"data\src1RGB.csv" 
+    # csv files in which data from corrected image for squares of checker will
+    # be stored             
+    corrected_XYZ_csv = r"data\src1CorXYZ.csv"
+    corrected_lin_csv = r"data\src1CorRGB.csv"
+    # csv with reference sRGB data of colours on checker
+    reference_csv_RGB = r"data\reference_RGB.csv"
+    # Image files in which the corrected images are saved
+    corrected_img_lin = r"img\src1Corlin.jpg"
+    corrected_img_sRGB = r"img\src1CorsRGB.jpg"
+    # map of images to be corrected
+    map_path = r"img\tobecorrected"
+    corrected_directory = r"img\tobecorrected\corrected"
+    
+    
+    # Fill in the shape of the colour checker
+    n_vertical_swatches = 5
+    n_horizontal_swatches = 6
+    total = n_vertical_swatches * n_horizontal_swatches
+
+    # Use the horizontal line in the figure to line up the checker horizontally
+    rotation = -1
+
+    # It is optional to crop the image if positioning the mask is too difficult,
+    # because the colour checker is small in the image
+    left = 900
+    top = 1600
+    right = 800
+    bottom = 1200
+
+    # Choose the width of the mask squares to fit inside the squares of the checker
+    swatch_width = 130
+
+    # Choose the position of the top left mask, using the pixel count on the axes
+    vertical_start = 140
+    horizontal_start = 20
+
+    # choose the vertical and horizontal steps so that each black mask is inside one
+    # of the squares on the colour checker
+    vertical_steps = 210
+    horizontal_steps = 210
+    
+    write_csv = 0
+    correct = 1
+    compare = 1
+    batch = 0
+    
+    # Choose number of correction terms out of: 
+    # [3, 5, 7, 8, 10, 11, 14, 16, 17, 19, 20, 22]
+    correction_terms = 20
+    
+# ============================================================================#
+    lin = 1
+    source_lin, source_XYZ, image_lin = m.createMasks(n_vertical_swatches,
+                n_horizontal_swatches, rotation, left, top, right, bottom,
+                swatch_width, vertical_start, horizontal_start, vertical_steps,
+                horizontal_steps, img_path, lin)
+    
+    if write_csv == 1:
+        m.writeCSVs(source_lin, source_XYZ, source_XYZ_csv, source_lin_csv)
+    
+    if correct == 1:
+        corrected, reference_lin, CCM = CC.ColourCorrect(image_lin, corrected_img_lin,
+                            corrected_img_sRGB, source_lin, reference_csv_RGB,
+                            correction_terms)
+        
+        if compare == 1: 
+            lin = 0
+            corrected_lin, corrected_XYZ, cor_image_lin = m.createMasks(
+                n_vertical_swatches, n_horizontal_swatches, rotation, left, 
+                top, right, bottom, swatch_width, vertical_start, 
+                horizontal_start, vertical_steps,horizontal_steps, 
+                corrected_img_lin, lin)
+            if write_csv == 1:
+                m.writeCSVs(corrected_lin, corrected_XYZ, corrected_XYZ_csv,
+                               corrected_lin_csv)
+            source_err_XYZ,corrected_err_XYZ, source_err_lin,\
+            corrected_err_lin, dE00_source, dE00_corrected = dP.diffPlot(source_lin,
+                                                reference_lin, corrected_lin)
+            
+            dP.diffChart(reference_lin, corrected_lin, source_lin)
+            
+            print(f"Average error in XYZ values for source image is {source_err_XYZ:.3f}%")
+            print(f"Average error in XYZ values for corrected image is {corrected_err_XYZ:.3f}%")
+            print(f"Average error in RGB values for source image is {source_err_lin:.3f}%")
+            print(f"Average error in RGB values for corrected image is {corrected_err_lin:.3f}%")
+            print(f"Average dE00 for source image is {dE00_source:.3f}")
+            print(f"Average dE00 for corrected image is {dE00_corrected:.3f}")
+            
+    if batch == 1:
+        CC.BatchCorrect(map_path, source_lin, reference_csv_RGB, correction_terms,
+                        corrected_directory)
+        
+    
+    
+    
+