Kleine Anpassungen

Der Dalt Algorithmus wird nun von dem Dalt-Button ausgeführt. Gleichzeitig wurde die Funktion showImage geschrieben, um Code zu verschlanken und lediglich die Switchfunktionen simulate und daltonize für die Auswahl der Simulationsart zu nutzen.
PS: Mehrere Bilder zum Testen eingefügt

Code/Dyschromasie-Applikation.py

@@ -1,219 +1,116 @@
 from PIL import Image, ImageTk
 import PIL
 import tkinter as tk
-from tkinter import filedialog, messagebox
 import cv2
 import numpy as np
-
-
-class Dyschromasie:
-    cb_image = np.array([]).astype('float64')
-    sim_image = np.array([]).astype('uint8')
-
-    def __init__(self, img_mat=np.array([]), rows=0, cols=0, kanaele=0):
-        self.rows = rows
-        self.cols = cols
-        self.kanaele = kanaele
-        self.img_mat = img_mat
-
-    T = np.array([[0.31399022, 0.63951294, 0.04649755],
-                  [0.15537241, 0.75789446, 0.08670142],
-                  [0.01775239, 0.10944209, 0.87256922]])
-
-    T_reversed = np.array([[5.47221206, -4.6419601, 0.16963708],
-                           [-1.1252419, 2.29317094, -0.1678952],
-                           [0.02980165, -0.19318073, 1.16364789]])
-
-    def gammaCorrection(self, v):
-        if v <= 0.04045 * 255:
-            return float(((v / 255) / 12.92))
-        elif v > 0.04045 * 255:
-            return float((((v / 255) + 0.055) / 1.055) ** 2.4)
-
-    def reverseGammaCorrection(self, v_reverse):
-        if v_reverse <= 0.0031308:
-            return int(255 * (12.92 * v_reverse))
-        elif v_reverse > 0.0031308:
-            return int(255 * (1.055 * v_reverse ** 0.41666 - 0.055))
-
-
-class Protanopie(Dyschromasie):
-    sim_mat = np.array([[0, 1.05118294, -0.05116099],
-                        [0, 1, 0],
-                        [0, 0, 1]])
-
-    def Simulate(self):
-        # Gammakorrektur durchfuehren
-        self.cb_image = np.copy(self.img_mat).astype('float64')
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.cb_image[i, j, x] = self.gammaCorrection(self.img_mat[i, j, x])
-
-        # Einzelne Pixelwertberechnung
-        for i in range(self.rows):
-            for j in range(self.cols):
-                self.cb_image[i, j] = np.flipud(self.T_reversed.dot(self.sim_mat).dot(self.T).dot(np.flipud(self.cb_image[i, j])))
-
-        self.sim_image = np.copy(self.cb_image)
-        self.sim_image = self.sim_image.astype('uint8')
-
-        # Rücktransformation der Gammawerte
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.sim_image[i, j, x] = self.reverseGammaCorrection(self.cb_image[i, j, x])
-
-        return self.sim_image
-
-
-class Deuteranopie(Dyschromasie):
-    sim_mat = np.array([[1, 0, 0],
-                        [0.9513092, 0, 0.04866992],
-                        [0, 0, 1]])
-
-    def Simulate(self):
-        # Gammakorrektur durchfuehren
-        self.cb_image = np.copy(self.img_mat).astype('float64')
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.cb_image[i, j, x] = self.gammaCorrection(self.img_mat[i, j, x])
-
-        # Einzelne Pixelwertberechnung
-        for i in range(self.rows):
-            for j in range(self.cols):
-                self.cb_image[i, j] = np.flipud(self.T_reversed.dot(self.sim_mat).dot(self.T).dot(np.flipud(self.cb_image[i, j])))
-
-        self.sim_image = np.copy(self.cb_image)
-        self.sim_image = self.sim_image.astype('uint8')
-
-        # Rücktransformation der Gammawerte
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.sim_image[i, j, x] = self.reverseGammaCorrection(self.cb_image[i, j, x])
-        return self.sim_image
-
-
-class Tritanopie(Dyschromasie):
-    sim_mat = np.array([[1, 0, 0],
-                        [0, 1, 0],
-                        [-0.86744736, 1.86727089, 0]])
-
-    def Simulate(self):
-        # Gammakorrektur durchfuehren
-        self.cb_image = np.copy(self.img_mat).astype('float64')
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.cb_image[i, j, x] = self.gammaCorrection(self.img_mat[i, j, x])
-
-        # Einzelne Pixelwertberechnung
-        for i in range(self.rows):
-            for j in range(self.cols):
-                self.cb_image[i, j] = np.flipud(self.T_reversed.dot(self.sim_mat).dot(self.T).dot(np.flipud(self.cb_image[i, j])))
-
-        self.sim_image = np.copy(self.cb_image)
-        self.sim_image = self.sim_image.astype('uint8')
-
-        # Rücktransformation der Gammawerte
-        for i in range(self.rows):
-            for j in range(self.cols):
-                for x in range(3):
-                    self.sim_image[i, j, x] = self.reverseGammaCorrection(self.cb_image[i, j, x])
-        return self.sim_image
+from Farbaenderung import Dyschromasie
+from Scrollbar import ScrollFrame
 
 root = tk.Tk()
+simGrad = tk.IntVar(root)
+
 root.title("Projekt Dyschromasie")
 
+SB = ScrollFrame(root)
+
 img = np.array([])
 rows = 0
 cols = 0
 kanaele = 0
 
-sim_pro     = tk.IntVar(root)
-sim_deut    = tk.IntVar(root)
-sim_tri     = tk.IntVar(root)
+sim_pro = tk.IntVar(root)
+sim_deut = tk.IntVar(root)
+sim_tri = tk.IntVar(root)
+
+simulationsGradient = tk.Scale(SB.frame, from_=0, to_=100, variable=simGrad, orient='horizontal')
+simulationsGradient.grid(column=0, row=1, columnspan=10)
+
 
 def browse():
     # Auswahl des FilePaths
     try:
-        path = tk.filedialog.askopenfilename(filetypes=[("Image File", '.jpg')])
+        path = tk.filedialog.askopenfilename(filetypes=[("Image File", '.jpg'), ("Image File", '.png')])
         im = Image.open(path)
     except:
         tk.messagebox.showerror(title='Datenfehler', message='Kein Bild gefunden/ausgewählt')
     global simulateButton
     if len(path) > 0:
         simulateButton.config(state='active')
+        daltonButton.config(state='active')
 
         # Anzeigen des Bildes
         tkimage = ImageTk.PhotoImage(im)
-        myvar = tk.Label(root, image=tkimage)
+        myvar = tk.Label(SB.frame, image=tkimage)
         myvar.image = tkimage
         myvar.grid(columnspan=5)
 
         # Einspeichern der Path-Informationen
         global img, rows, cols, kanaele
         img = cv2.imread(path)
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
         rows, cols, kanaele = img.shape
 
 
+def showImage(img, rows, cols, kanaele, sim_faktor, sim_kind, sim_art):
+    color_blindness = Dyschromasie(img, rows, cols, kanaele, sim_faktor, sim_kind)
+    if sim_art == 'Sim':
+        color_blindness_mat = np.copy(color_blindness.Simulate()).astype('uint8')
+    else:
+        color_blindness_mat = np.copy(color_blindness.daltonize()).astype('uint8')
+
+    T = tk.Text(SB.frame, height=1, width=15)
+    T.grid(columnspan=5)
+    print_string = sim_kind + ' ' + str(round(color_blindness.sim_faktor * 100)) + "%"
+    T.insert('current', print_string)
+
+    conv_SimulationPic = ImageTk.PhotoImage(image=PIL.Image.fromarray(color_blindness_mat))
+    sim_pic = tk.Label(SB.frame, image=conv_SimulationPic)
+    sim_pic.Image = conv_SimulationPic
+    sim_pic.grid(columnspan=5)
+
+
 def simulate():
     global img, rows, cols, kanaele, sim_pro, sim_deut, sim_tri
-
     if sim_deut.get():
-        d = Deuteranopie(img, rows, cols, kanaele)
-        display_array_deut = cv2.cvtColor(np.copy(d.Simulate()), cv2.COLOR_BGR2RGB)
+        showImage(img, rows, cols, kanaele, simGrad.get()/100, 'Deuteranop', 'Sim')
 
-        T = tk.Text(root,height=1,width=15)
-        T.grid(columnspan=5)
-        T.insert('current',"Deutranopie:")
-
-        conv_SimulationPic_deut = ImageTk.PhotoImage(image=PIL.Image.fromarray(display_array_deut))
-        sim_pic_deut = tk.Label(root, image=conv_SimulationPic_deut)
-        sim_pic_deut.Image = conv_SimulationPic_deut
-        sim_pic_deut.grid(columnspan=5)
     elif sim_tri.get():
-        t = Tritanopie(img, rows, cols, kanaele)
-        display_array_tri = cv2.cvtColor(np.copy(t.Simulate()), cv2.COLOR_BGR2RGB)
+        showImage(img, rows, cols, kanaele, simGrad.get() / 100, 'Tritanop', 'Sim')
 
-        T = tk.Text(root, height=1, width=15)
-        T.grid(columnspan=5)
-        T.insert('current', "Tritanopie:")
-
-        conv_SimulationPic_tri = ImageTk.PhotoImage(image=PIL.Image.fromarray(display_array_tri))
-        sim_pic_tri = tk.Label(root, image=conv_SimulationPic_tri)
-        sim_pic_tri.Image = conv_SimulationPic_tri
-        sim_pic_tri.grid(columnspan=5)
     elif sim_pro.get():
-        p = Protanopie(img, rows, cols, kanaele)
-        display_array_pro = cv2.cvtColor(np.copy(p.Simulate()), cv2.COLOR_BGR2RGB)
-
-        T = tk.Text(root, height=1, width=15)
-        T.grid(columnspan=5)
-        T.insert('current', "Protanopie:")
-
-        conv_SimulationPic_pro = ImageTk.PhotoImage(image=PIL.Image.fromarray(display_array_pro))
-        sim_pic_pro = tk.Label(root, image=conv_SimulationPic_pro)
-        sim_pic_pro.Image = conv_SimulationPic_pro
-        sim_pic_pro.grid(columnspan=5)
+        showImage(img, rows, cols, kanaele, simGrad.get() / 100, 'Protanop', 'Sim')
 
 
+def daltonize():
+    global img, rows, cols, kanaele, sim_pro, sim_deut, sim_tri
+    if sim_deut.get():
+        showImage(img, rows, cols, kanaele, simGrad.get()/100, 'Deuteranop', 'Dalt')
 
-btn = tk.Button(root, text="Browse", width=25, command=browse, bg='light blue')
-btn.grid(column = 0, row = 0,columnspan=2)
+    elif sim_tri.get():
+        showImage(img, rows, cols, kanaele, simGrad.get() / 100, 'Tritanop', 'Dalt')
 
-simulateButton = tk.Button(root, text="Simulate", width=25, command=simulate, bg='light blue')
-simulateButton.grid(column = 1, row = 0,columnspan=2)
+    elif sim_pro.get():
+        showImage(img, rows, cols, kanaele, simGrad.get() / 100, 'Protanop', 'Dalt')
+
+
+browseButton = tk.Button(SB.frame, text="Browse", width=25, command=browse, bg='light blue')
+browseButton.grid(column=0, row=0, columnspan=1)
+
+simulateButton = tk.Button(SB.frame, text="Simulate", width=25, command=simulate, bg='light blue')
+simulateButton.grid(column=1, row=0, columnspan=1)
 simulateButton.config(state='disabled')
 
-checkButton_p = tk.Checkbutton(root, text="Protanop", variable=sim_pro, onvalue=1, offvalue=0, height=5, width=20)
-checkButton_d = tk.Checkbutton(root, text="Deutanop", variable=sim_deut, onvalue=1, offvalue=0, height=5, width=20)
-checkButton_t = tk.Checkbutton(root, text="Tritanop", variable=sim_tri, onvalue=1, offvalue=0, height=5, width=20)
+daltonButton = tk.Button(SB.frame, text="Daltonize", width=25, command=daltonize, bg='light blue')
+daltonButton.grid(column=2, row=0, columnspan=1)
+daltonButton.config(state='disabled')
 
-checkButton_p.grid(column = 0, row = 1)
-checkButton_d.grid(column = 1, row = 1)
-checkButton_t.grid(column = 2, row = 1)
+checkButton_p = tk.Checkbutton(SB.frame, text="Protanop", variable=sim_pro, onvalue=1, offvalue=0, height=5, width=20)
+checkButton_d = tk.Checkbutton(SB.frame, text="Deutanop", variable=sim_deut, onvalue=1, offvalue=0, height=5, width=20)
+checkButton_t = tk.Checkbutton(SB.frame, text="Tritanop", variable=sim_tri, onvalue=1, offvalue=0, height=5, width=20)
 
+checkButton_p.grid(column=0, row=2)
+checkButton_d.grid(column=1, row=2)
+checkButton_t.grid(column=2, row=2)
+
+SB.update()
 root.mainloop()

Code/Dyschromasie.py

@@ -77,8 +77,7 @@ S_t = np.array([[1, 0, 0],                     #Simulationsmatrix fuer Tritanopi
 #Multiplikation der einzelnen Pixel
 for i in range(rows):
     for j in range(cols):
-        cb_image[i,j] = T_reversed.dot(S_p).dot(T).dot(cb_image[i,j])
-        # Da OpenCV Pixelwerte in RGB speichert, aber BGR für den Algorithmus nötig ist, muss die Matrix mit flipud gedreht werden
+        cb_image[i,j] = T_reversed.dot(S_t).dot(T).dot(cb_image[i,j])
 
 sim_image = np.copy(cb_image)
 sim_image = sim_image.astype('uint8')

Code/Farbaenderung.py

@@ -0,0 +1,126 @@
+import numpy as np
+import cv2
+
+
+def createGammaLookup():
+    return np.array([removeGammaCorrection(i) for i in np.arange(0, 256)]).astype("float64")
+
+
+def createReverseGammaLookup():
+    return np.array([applyGammaCorrection(i / 255) for i in np.arange(0.0, 256.0)]).astype("uint8")
+
+
+def removeGammaCorrection(v):
+    if v <= 0.04045 * 255:
+        return (v / 255) / 12.92
+    elif v > 0.04045 * 255:
+        return (((v / 255) + 0.055) / 1.055) ** 2.4
+
+
+def applyGammaCorrection(v_reverse):
+    if abs(v_reverse) <= 0.0031308:
+        return round(255 * (12.92 * abs(v_reverse)))
+    else:
+        if (round(255 * (1.055 * abs(v_reverse) ** 0.41666 - 0.055))) > 255:
+            return 255 - (round(255 * (1.055 * abs(v_reverse) ** 0.41666 - 0.055)) - 255)
+        else:
+            return round(255 * (1.055 * abs(v_reverse) ** 0.41666 - 0.055))
+
+
+class Dyschromasie:
+    cb_image = np.array([]).astype('float64')
+    sim_image = np.array([]).astype('int64')
+
+    def __init__(self, img_mat=np.array([]), rows=0, cols=0, kanaele=0, sim_faktor=0, sim_kind='Deuteranop'):
+        self.rows = rows
+        self.cols = cols
+        self.kanaele = kanaele
+        self.img_mat = img_mat
+        self.sim_faktor = sim_faktor
+        self.sim_kind = sim_kind
+
+    T = np.array([[0.31399022, 0.63951294, 0.04649755],
+                  [0.15537241, 0.75789446, 0.08670142],
+                  [0.01775239, 0.10944209, 0.87256922]])
+
+    T_reversed = np.array([[5.47221206, -4.6419601, 0.16963708],
+                           [-1.1252419, 2.29317094, -0.1678952],
+                           [0.02980165, -0.19318073, 1.16364789]])
+
+    def Simulate(self):
+        removeGammaCorrectionLUT = createGammaLookup()
+
+        if self.sim_kind == 'Protanop':
+            sim_mat = np.array([[(1 - self.sim_faktor), 1.05118294 * self.sim_faktor, -0.05116099 * self.sim_faktor],
+                                [0, 1, 0],
+                                [0, 0, 1]])
+        elif self.sim_kind == 'Deuteranop':
+            sim_mat = np.array([[1, 0, 0],
+                                [0.9513092 * self.sim_faktor, (1 - self.sim_faktor), 0.04866992 * self.sim_faktor],
+                                [0, 0, 1]])
+        elif self.sim_kind == 'Tritanop':
+            sim_mat = np.array([[1, 0, 0],
+                                [0, 1, 0],
+                                [-0.86744736 * self.sim_faktor, 1.86727089 * self.sim_faktor, (1 - self.sim_faktor)]])
+
+        # Gammakorrektur durchfuehren
+        self.cb_image = np.copy(self.img_mat).astype('float64')
+
+        self.cb_image = cv2.LUT(self.img_mat, removeGammaCorrectionLUT)
+
+        rechen_Mat = np.copy(self.T_reversed.dot(sim_mat).dot(self.T))
+
+        # Einzelne Pixelwertberechnung
+        for i in range(self.rows):
+            for j in range(self.cols):
+                self.cb_image[i, j] = rechen_Mat.dot(self.cb_image[i, j])
+
+        self.sim_image = np.copy(self.cb_image)
+        self.sim_image = self.sim_image.astype('int64')
+        # Rücktransformation der Gammawerte
+        for i in range(self.rows):
+            for j in range(self.cols):
+                for x in range(3):
+                    self.sim_image[i, j, x] = applyGammaCorrection(self.cb_image[i, j, x])
+
+        return self.sim_image.astype('uint8')
+
+    def daltonize(self):
+
+        err2mod = np.array([[0, 0, 0], [0.7, 1, 0], [0.7, 0, 1]])
+        simulated_image = self.Simulate()
+
+        E = np.copy(simulated_image).astype('int32')
+        for i in range(self.rows):
+            for j in range(self.cols):
+                for x in range(3):
+                    E[i, j, x] = abs(int(self.img_mat[i, j, x]) - int(simulated_image[i, j, x]))
+
+        ERR = np.zeros_like(self.img_mat).astype('int32')
+
+        for i in range(self.rows):
+            for j in range(self.cols):
+                err = E[i, j, :3]
+                ERR[i, j, :3] = np.dot(err2mod, err)
+
+        dtpn = np.copy(self.img_mat).astype('int32')
+
+        for i in range(self.rows):
+            for j in range(self.cols):
+                for x in range(3):
+                    dtpn[i, j, x] = abs(int(ERR[i, j, x]) + int(self.img_mat[i, j, x]))
+
+        for i in range(self.rows):
+            for j in range(self.cols):
+                dtpn[i, j, 0] = max(0, dtpn[i, j, 0])
+                dtpn[i, j, 0] = min(255, dtpn[i, j, 0])
+                dtpn[i, j, 1] = max(0, dtpn[i, j, 1])
+                dtpn[i, j, 1] = min(255, dtpn[i, j, 1])
+                dtpn[i, j, 2] = max(0, dtpn[i, j, 2])
+                dtpn[i, j, 2] = min(255, dtpn[i, j, 2])
+
+        result = dtpn.astype('uint8')
+
+        dalt = Dyschromasie(result, self.rows, self.cols, self.kanaele, self.sim_faktor, self.sim_kind)
+        return dalt.Simulate()
+

Code/Scrollbar.py

@@ -0,0 +1,59 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox
+
+class AutoScrollbar(tk.Scrollbar):
+   # A scrollbar that hides itself if it's not needed.
+   # Only works if you use the grid geometry manager!
+    def set(self, lo, hi):
+        if float(lo) <= 0.0 and float(hi) >= 1.0:
+            # grid_remove is currently missing from Tkinter!
+            self.tk.call("grid", "remove", self)
+        else:
+            self.grid()
+        tk.Scrollbar.set(self, lo, hi)
+    def pack(self, **kw):
+        raise TclError("cannot use pack with this widget")
+    def place(self, **kw):
+        raise TclError("cannot use place with this widget")
+
+class ScrollFrame:
+    def __init__(self, master):
+
+        self.vscrollbar = AutoScrollbar(master)
+        self.vscrollbar.grid(row=0, column=1, sticky='ns')
+        self.hscrollbar = AutoScrollbar(master, orient='horizontal')
+        self.hscrollbar.grid(row=1, column=0, sticky='ew')
+
+        self.canvas = tk.Canvas(master, yscrollcommand=self.vscrollbar.set,
+                        xscrollcommand=self.hscrollbar.set)
+        self.canvas.grid(row=0, column=0, sticky='nsew')
+
+        self.vscrollbar.config(command=self.canvas.yview)
+        self.hscrollbar.config(command=self.canvas.xview)
+
+        # make the canvas expandable
+        master.grid_rowconfigure(0, weight=1)
+        master.grid_columnconfigure(0, weight=1)
+
+        # create frame inside canvas
+        self.frame = tk.Frame(self.canvas)
+        self.frame.rowconfigure(1, weight=1)
+        self.frame.columnconfigure(1, weight=1)
+
+        # update the frame
+        self.frame.bind("<Configure>", self.reset_scrollregion)
+
+    def reset_scrollregion(self, event):
+        self.canvas.configure(scrollregion=self.canvas.bbox('all'))
+
+    def update(self):
+        self.canvas.create_window(0, 0, anchor='nw', window=self.frame)
+        self.frame.update_idletasks()
+        self.canvas.config(scrollregion=self.canvas.bbox("all"))
+
+        if self.frame.winfo_reqwidth() != self.canvas.winfo_width():
+            # update the canvas's width to fit the inner frame
+            self.canvas.config(width = self.frame.winfo_reqwidth())
+        if self.frame.winfo_reqheight() != self.canvas.winfo_height():
+            # update the canvas's width to fit the inner frame
+            self.canvas.config(height = self.frame.winfo_reqheight())