src/methods/brice_convers/dataEvaluation.py

+from src.methods.brice_convers.dataHandler import DataHandler
+from src.utils import psnr, ssim
+from sklearn.metrics import f1_score, mean_squared_error
+import numpy as np
+
+class DataEvaluation:
+    def __init__(self, DataHandler: DataHandler):
+        DataEvaluation.DataHandler = DataHandler
+
+    def print_metrics(self, indexImage, method):
+        DataEvaluation.DataHandler.indexImageExists(indexImage)
+
+        img = DataEvaluation.DataHandler.load_image(indexImage)
+        res = DataEvaluation.DataHandler.get_reconstructed_image(indexImage, method)
+
+        ssimMetric = ssim(img, res)
+        psnrMetrc = psnr(img, res)
+        mse = mean_squared_error(img.flatten(), res.flatten())
+        mseRedPixels = mean_squared_error(img[:,:,0], res[:,:,0])
+        mseGreenPixels = mean_squared_error(img[:,:,1], res[:,:,1])
+        mseBluePixels = mean_squared_error(img[:,:,2], res[:,:,2])
+        miMetric = DataEvaluation.MI(img, res)
+        ccMetric = DataEvaluation.CC(img, res)
+        sadMetric = DataEvaluation.SAD(img, res)
+        lsMetric = DataEvaluation.LS(img, res)
+
+        print("[INFO] Metrics for image {}".format(indexImage))
+        print("#" * 30)
+        print(" SSIM: {:.6}  ".format(ssimMetric))
+        print(" PSNR: {:.6}   ".format(psnrMetrc))
+        print(" MSE : {:.3e}    ".format(mse))
+        print(" MSE (R): {:.3e}    ".format(mseRedPixels))
+        print(" MSE (G): {:.3e}    ".format(mseGreenPixels))
+        print(" MSE (B): {:.3e}    ".format(mseBluePixels))
+        print(" MI: {:.6}     ".format(miMetric))
+        print(" CC: {:.6}    ".format(ccMetric))
+        print(" SAD: {:.6} ".format(sadMetric))
+        print(" LS: {:.3e} ".format(lsMetric))
+        print("#" * 30)
+
+    #Mutual Information
+    def MI(img_mov, img_ref):
+        hgram, x_edges, y_edges = np.histogram2d(img_mov.ravel(), img_ref.ravel(), bins=20)
+        pxy = hgram / float(np.sum(hgram))
+        px = np.sum(pxy, axis=1) # marginal for x over y
+        py = np.sum(pxy, axis=0) # marginal for y over x
+        px_py = px[:, None] * py[None, :] # Broadcast to multiply marginals
+        # Now we can do the calculation using the pxy, px_py 2D arrays
+        nzs = pxy > 0 # Only non-zero pxy values contribute to the sum
+        return np.sum(pxy[nzs] * np.log(pxy[nzs] / px_py[nzs]))
+
+    # Cross Correlation
+    def CC(img_mov, img_ref):
+        # Vectorized versions of c,d,e
+        a = img_mov.astype('float64')
+        b = img_ref.astype('float64')
+
+        # Calculating mean values
+        AM = np.mean(a)
+        BM = np.mean(b)
+
+        c_vect = (a - AM) * (b - BM)
+        d_vect = (a - AM) ** 2
+        e_vect = (b - BM) ** 2
+
+        # Finally get r using those vectorized versions
+        r_out = np.sum(c_vect) / float(np.sqrt(np.sum(d_vect) * np.sum(e_vect)))
+        return r_out
+
+    #Sum of Absolute Differences
+    def SAD(img_mov, img_ref):
+        img1 = img_mov.astype('float64')
+        img2 = img_ref.astype('float64')
+        ab = np.abs(img1 - img2)
+        sav = np.sum(ab.ravel())
+        sav /= ab.ravel().shape[0]
+        return sav
+
+    #Sum of Least Squared Errors
+    def LS(img_mov, img_ref):
+        img1 = img_mov.astype('float64')
+        img2 = img_ref.astype('float64')
+        r = (img1 - img2)**2
+        sse = np.sum(r.ravel())
+        sse /= r.ravel().shape[0]
+        return sse
+

src/methods/brice_convers/main_template.py

+import src.methods.brice_convers.dataHandler as DataHandler
+import src.methods.brice_convers.dataEvaluation as DataEvaluation
+import time
+
+WORKING_DIRECOTRY_PATH = "SICOM_Image_Analysis/sicom_image_analysis_project/"
+
+DataHandler = DataHandler.DataHandler(WORKING_DIRECOTRY_PATH)
+DataEvaluation = DataEvaluation.DataEvaluation(DataHandler)
+
+def main(DataHandler):
+
+    IMAGE_PATH = WORKING_DIRECOTRY_PATH + "images/"
+
+    CFA_NAME = "quad_bayer"
+
+    METHOD = "menon"
+
+    startTime = time.time()
+
+    DataHandler.list_images(IMAGE_PATH)
+
+    DataHandler.print_list_images()
+
+    DataHandler.compute_CFA_images(CFA_NAME)
+
+    DataHandler.compute_reconstruction_images(METHOD, {"cfa": CFA_NAME})
+
+    DataHandler.plot_reconstructed_image(0, METHOD, {"cfa": CFA_NAME}, zoomSize="large")
+
+    DataEvaluation.print_metrics(0, METHOD)
+
+    endTime = time.time()
+
+    print("[INFO] Elapsed time: " + str(endTime - startTime) + "s")
+
+    print("[INFO] End")
+
+if __name__ == "__main__":
+    main(DataHandler)

src/methods/brice_convers/utilities.py

+import os
+import cv2
+
+def folderExists(path):
+	CHECK_FOLDER = os.path.isdir(path)
+
+	# If folder doesn't exist, it creates it.
+	if not CHECK_FOLDER:
+		os.makedirs(path)
+		print("[DATA] You created a new folder : " +  str(path))
+
+import numpy as np
+
+def quad_bayer_to_bayer(quad_bayer_pattern):
+    # We test that thee quad bayer size fit with a multiple of 2 for width and height). If not, we pad it.
+	if quad_bayer_pattern.shape[0] % 2 != 0 or quad_bayer_pattern.shape[1] % 2 != 0:
+		print("[INFO] The quad bayer pattern size is not valid. We need to pad it.")
+
+		pad_schema = []
+
+		if quad_bayer_pattern.shape[0] % 2 != 0:
+				pad_schema.append([0, 1])
+
+		if quad_bayer_pattern.shape[1] % 2 != 0:
+				pad_schema.append([0, 1])
+		else:
+				pad_schema.append([0, 0])
+
+		quad_bayer_pattern = np.pad(quad_bayer_pattern, pad_schema, mode="reflect")[:, 2:]
+
+	# we create a new bayer pattern with the good size
+	bayer_pattern = np.zeros((quad_bayer_pattern.shape[0] // 2, quad_bayer_pattern.shape[1] // 2))
+
+	# We combine adjacent pixels to create the Bayer pattern
+	for i in range(0, quad_bayer_pattern.shape[0], 2):
+		for j in range(0, quad_bayer_pattern.shape[1], 2):
+			bayer_pattern[i // 2, j // 2] = (
+			quad_bayer_pattern[i, j] +
+			quad_bayer_pattern[i, j + 1] +
+			quad_bayer_pattern[i + 1, j] +
+			quad_bayer_pattern[i + 1, j + 1]
+		) / 4
+
+	# We resize bayer iamge to the original image size
+
+	#return cv2.resize(bayer_pattern, quad_bayer_pattern.shape, interpolation=cv2.INTER_CUBIC)
+	return bayer_pattern