denoising-images-using-conditional-dcgans/preprocessing.py at master · fadybaly/denoising-images-using-conditional-dcgans · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
# -*- coding: utf-8 -*-
"""
Created on Fri Apr 13 14:55:06 2018

@author: Fady Baly
"""
import os
import cv2
import numpy as np
from noise_func import noisy

def load_and_preprocess_dataset(data_dir, noise):
    if noise == 'pix':
        A = []
        B = []
        idx = 0
        flag = 0
        for path, _, files in os.walk(data_dir):
            for file in files:
                im = cv2.imread(path + '/' + file)
                A.append(im)
                if idx==4000:
                    flag = 1
                    break
                idx += 1
            if flag == 1:
                break
        A = np.asarray(A, dtype=np.uint8)
        for im in A:
            B.append(noisy('pix', im))
        B = np.asarray(B)
    #
        A, mean_1, mean_2, mean_3, X_min, X_max = standardize_and_preprocess_orig(np.array(A, dtype = np.int32))
        B = standardize_and_preprocess_noise(np.array(B, dtype=np.int32), mean_1, mean_2, mean_3, X_min, X_max)
        return A, B
    else:
        A = []
        B = []
        idx = 0
        flag = 0
        for path, _, files in os.walk(data_dir):
            for file in files:
                im = cv2.imread(path + '/' + file)
                A.append(im)
                if idx==5000:
                    flag = 1
                    break
                idx += 1
            if flag == 1:
                break
        A = np.asarray(A, dtype=np.int32)
        A = standardize_and_preprocess(A)

        for im in A:
            B.append(noisy('gauss', im))
        B = np.asarray(B)
        return A, B


def standardize_and_preprocess(X):
    mean_1 = np.mean(X[:,:,:,0])
    mean_2 = np.mean(X[:,:,:,1])
    mean_3 = np.mean(X[:,:,:,2])
    X[:,:,:,0] = X[:,:,:,0] - mean_1
    X[:,:,:,1] = X[:,:,:,1] - mean_2
    X[:,:,:,2] = X[:,:,:,2] - mean_3
    X = (X - np.min(X))/(np.max(X) - np.min(X))

    return X


def standardize_and_preprocess_orig(X):
    # take out the mean per channel
    mean_1 = np.mean(X[:,:,:,0])
    mean_2 = np.mean(X[:,:,:,1])
    mean_3 = np.mean(X[:,:,:,2])
    X[:,:,:,0] = X[:,:,:,0] - mean_1
    X[:,:,:,1] = X[:,:,:,1] - mean_2
    X[:,:,:,2] = X[:,:,:,2] - mean_3
    # normalize to range [0, 1]
    X_min = np.min(X)
    X_max = np.max(X)
    X = (X - X_min)/(X_max - X_min)
    return X, mean_1, mean_2, mean_3, X_min, X_max

def standardize_and_preprocess_noise(X, mean_1, mean_2, mean_3, X_min, X_max):
    # take out the mean per channel
    X[:,:,:,0] = X[:,:,:,0] - mean_1
    X[:,:,:,1] = X[:,:,:,1] - mean_2
    X[:,:,:,2] = X[:,:,:,2] - mean_3
    # normalize to range [0, 1]
    X = (X - X_min)/(X_max - X_min)
    return X