def main():
#Approximate mean values obtained by running K-means using scikit library
data, image = read_data("../data/cow.txt", True)
X = np.reshape(image, (image.shape[0] * image.shape[1], image.shape[2]))
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
clusters = kmeans.cluster_centers_
fit_EM(clusters[0],clusters[1],"cow",data,image)
data, image = read_data("../data/fox.txt", True)
X = np.reshape(image, (image.shape[0] * image.shape[1], image.shape[2]))
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
clusters = kmeans.cluster_centers_
fit_EM(clusters[0],clusters[1], "fox", data, image)
data, image = read_data("../data/owl.txt", True)
X = np.reshape(image, (image.shape[0] * image.shape[1], image.shape[2]))
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
clusters = kmeans.cluster_centers_
fit_EM(clusters[0], clusters[1],"owl",data,image)
data, image = read_data("../data/zebra.txt", True)
X = np.reshape(image, (image.shape[0] * image.shape[1], image.shape[2]))
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
clusters = kmeans.cluster_centers_
fit_EM(clusters[0], clusters[1], "zebra", data, image)
def variational_inference(data):
entropy = 0
new_entropy = 1
mus = np.zeros(data.shape)
# initialize mu
for i in range(data.shape[0]):
for j in range(data.shape[1]):
if data[i, j] == 1:
mus[i, j] = L1.pdf(1) - L1.pdf(-1)
else:
mus[i, j] = L_1.pdf(1) - L_1.pdf(-1)
entropy = compute_entropy(data, mus)
iter = 0
print("initialized")
while abs(entropy - new_entropy) > 0.0001:
iter += 1
entropy = new_entropy
for i in range(data.shape[0]):
for j in range(data.shape[1]):
mus = update_mu(i, j, data, mus)
new_entropy = compute_entropy(data, mus)
print(new_entropy)
iter_mus = mus.copy()
denoized_data = np.round(iter_mus)
denoized_data = transform_back_values(denoized_data)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data,
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt')
read_data(
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt', True, False, True)
return mus
def output(data_dict, filename, prefix='outputs/a2/'):
for type, data in data_dict.items():
write_data(data, prefix + type + '_' + filename)
read_data(prefix + type + '_' + filename,
False,
save=True,
save_name=prefix + type + '_' +
filename.replace('.txt', '.jpg'))
def main(): # Denoise noise images 1-4 using the gibbs sampling algorithm and save the # denoised data matrix and denoised image into text and png files respectively for a in range(1,5): noisetxt = "../a1/" + str(a) + "_noise.txt" print(noisetxt) data, image = read_data(noisetxt, True) data_arr = data_to_arr(data) new_data_arr = gibbs_sample(data_arr, 15) new_data = arr_to_data(new_data_arr) denoisetxt = "../output/" + str(a) + "_denoise_gibbs.txt" write_data(new_data, denoisetxt) denoisepng = "../output/" + str(a) + "_denoise_gibbs.png" read_data(denoisetxt, True, False, True, denoisepng)
def denoise_gibbs(filenumber):
"""transform data, preforms gibbs sampling, transform back data"""
data, image = read_data('../a1/' + str(filenumber) + '_noise.txt', True)
data = transform_data_shape(data)
# put data in {-1, 1} space
data = transform_data_values(data)
denoized_data = gibbs_sampling(data)
denoized_data = transform_back_values(denoized_data)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data, 'final_denoised' + str(J) + '_J_' + str(sigma) +
'_sigma_' + str(filenumber) + '_noise.txt')
read_data(
'final_denoised' + str(J) + '_J_' + str(sigma) + '_sigma_' +
str(filenumber) + '_noise.txt', True, False, True)
return denoized_data
def main():
# Segment cow, fox, owl and zebra images using Expectation-Maximisation
# and save corresponding mask, seg1 and seg2 into text and jpg files
names = ['cow', 'fox', 'owl', 'zebra']
for a in range(len(names)):
inputtxt = "../a2/" + names[a] + ".txt"
print(inputtxt)
data, image = read_data(inputtxt, False)
data_arr = data_to_arr(data)
responsibilities = determine_responsibilities(data_arr, 10)
mask_data, seg1_data, seg2_data = segment_image(data, responsibilities)
write_read_data(names[a], "mask", mask_data)
write_read_data(names[a], "seg1", seg1_data)
write_read_data(names[a], "seg2", seg2_data)
def main():
for img in range(2, 3):
print("Denoising for image " + str(img))
data, image = read_data("../data/" + str(img) + "_noise.txt",
True,
visualize=True)
print(data.shape)
print(image.shape)
image[image == 0] = -1
image[image == 255] = 1
avg = denoise(image, 0.7, 20, 100)
avg[avg >= 0] = 255
avg[avg < 0] = 0
print(avg.shape)
width = avg.shape[0]
height = avg.shape[1]
counter = 0
for i in range(0, width):
for j in range(0, height):
data[counter][2] = avg[i][j][0]
counter = counter + 1
write_data(data, "../output/" + str(img) + "_denoise.txt")
read_data("../output/" + str(img) + "_denoise.txt",
True,
save=True,
save_name="../output/" + str(img) + "_denoise.jpg")
print("Finished writing data. Please check " + str(img) +
"_denoise.jpg \n")
def __init__(self, fname):
#Variable holders for data
self.data = 0
self.image = 0
self.X = 0
#Variable holders for probability related
self.posterior = [[0, 0]]
self.prior = [0, 0]
self.normalization = [0, 0]
self.post_sum = [0, 0]
self.Mean = [[0, 0, 0], [0, 0, 0]]
self.Cov1 = np.asarray([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
self.Cov2 = np.asarray([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
#Preprocessing of data
self.data, self.image = read_data(fname, True)
self.X = self.data[:, 2:]
#Initialization of means,variance
self.Mean[0] = [self.X[0][0], self.X[0][1], self.X[0][2]]
temp = [0, 0, 0]
for i in self.X: #finding the farthest value from cluster one and the same is assigned as cluster 2
if temp[0] < ((self.Mean[0][0] - i[0]) * (self.Mean[0][0] - i[0])):
temp[0] = (self.Mean[0][0] - i[0]) * (self.Mean[0][0] - i[0])
self.Mean[1][0] = i[0]
if temp[1] < ((self.Mean[0][1] - i[1]) * (self.Mean[0][1] - i[1])):
temp[1] = (self.Mean[0][1] - i[1]) * (self.Mean[0][1] - i[1])
self.Mean[1][1] = i[1]
if temp[2] < ((self.Mean[0][2] - i[2]) * (self.Mean[0][2] - i[2])):
temp[2] = (self.Mean[0][2] - i[2]) * (self.Mean[0][2] - i[2])
self.Mean[1][2] = i[2]
self.Cov1 = np.asarray([[20, 0, 0], [0, 20, 0], [0, 0, 20]])
self.Cov1 = np.cov(self.Cov1) #covariance 1
self.Cov2 = np.asarray([[15, 0, 0], [0, 15, 0], [0, 0, 15]])
self.Cov2 = np.cov(self.Cov2)
self.expect_maxim(fname)
def sampler(input, output, c, J, lamda, n_iter):
_, noisy_img = io_data.read_data(input, True)
# Convert to shape [rows, cols]
noisy_img = np.asarray(noisy_img).reshape(noisy_img.shape[0:2])
noisy_img[noisy_img < 128] = -1 # Use comparision for float.
noisy_img[noisy_img > 128] = 1
# Initialize mean value.
mean = np.zeros(noisy_img.shape)
L_1 = norm.logpdf(noisy_img, 1, c * c)
L_neg1 = norm.logpdf(noisy_img, -1, c * c)
for _ in range(n_iter):
updated_mean = np.zeros(noisy_img.shape)
for i in range(noisy_img.shape[0]):
for j in range(noisy_img.shape[1]):
nbr = 0
if i > 0:
nbr += mean[i - 1][j]
if i < noisy_img.shape[0] - 1:
nbr += mean[i + 1][j]
if j > 0:
nbr += mean[i][j - 1]
if j < noisy_img.shape[1] - 1:
nbr += mean[i][j + 1]
updated_mean[i][j] = lamda * mean[i][j] + \
(1 - lamda) * np.tanh(nbr * J + 0.5 * (L_1[i][j] - L_neg1[i][j]))
mean = updated_mean
# Restore the graph.
noisy_img[mean > 0] = 255
noisy_img[mean < 0] = 0
noisy_img = np.expand_dims(noisy_img, 2)
# Save the data.
cv2.imwrite(output, noisy_img)
def sampler(input, output, var, J, n_iter):
_, noisy_img = io_data.read_data(input, True)
# Convert to shape [rows, cols]
noisy_img = np.asarray(noisy_img).reshape(noisy_img.shape[0:2])
noisy_img[noisy_img < 128] = -1 # Use comparision for float.
noisy_img[noisy_img > 128] = 1
norm_1 = norm.pdf(noisy_img, 1, var)
norm_negative_1 = norm.pdf(noisy_img, -1, var)
for iter in range(n_iter):
for i in range(noisy_img.shape[0]):
for j in range(noisy_img.shape[1]):
nbr = 0
if i > 0:
nbr += noisy_img[i - 1][j]
if i < noisy_img.shape[0] - 1:
nbr += noisy_img[i + 1][j]
if j > 0:
nbr += noisy_img[i][j - 1]
if j < noisy_img.shape[1] - 1:
nbr += noisy_img[i][j + 1]
potential_1 = math.exp(J * nbr)
potential_negative_1 = math.exp(-J * nbr)
prob_1 = norm_1[i][j] * potential_1
prob_negative_1 = norm_negative_1[i][j] * potential_negative_1
# Normalize.
prob_1 /= (prob_1 + prob_negative_1)
noisy_img[i][j] = (np.random.rand() < prob_1) * 2 - 1
noisy_img[noisy_img > 0] = 255
noisy_img[noisy_img < 0] = 0
noisy_img = np.expand_dims(noisy_img, 2)
# Save the data.
cv2.imwrite(output, noisy_img)
def main():
prefix = 'a2/'
for filename in ['cow.txt', 'fox.txt', 'owl.txt', 'zebra.txt']:
# for filename in ['owl.txt']:
print('Solving ' + filename + ':...')
data, image = read_data(prefix + filename, True)
eps = 0.5
if (filename == 'owl.txt'):
mix0 = 0.4
means = np.array([[55, 0, 20], [80, 0, 0]])
cov0 = np.array([[20, 0, 0], [0, 2, 0], [0, 0, 10]])
cov1 = np.array([[42, 0, 0], [0, 1, 0], [0, 0, 10]])
else:
X = np.reshape(image,
(image.shape[0] * image.shape[1], image.shape[2]))
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
# set covs, coefficients
cluster_map = pd.DataFrame()
cluster_map['data'] = X.tolist()
cluster_map['cluster'] = kmeans.labels_
cluster0 = cluster_map[cluster_map.cluster == 0]['data']
cluster1 = cluster_map[cluster_map.cluster == 1]['data']
cov0 = np.cov(np.transpose(cluster0.tolist()))
cov1 = np.cov(np.transpose(cluster1.tolist()))
mix0 = float(len(cluster0)) / len(cluster_map)
means = kmeans.cluster_centers_
back_data, front_data, mask_data = fit_EM(image,
data,
means,
cov0,
cov1,
mix0,
eps=eps)
data_dict = {'back': back_data, 'front': front_data, 'mask': mask_data}
output(data_dict, filename)
positions = list(it.product(np.arange(r),np.arange(c)))
np.random.shuffle(positions)
for n in range(niter):
Z = X_list[n].copy()
for i in positions:
s = sum([Z[j[0],j[1]] for j in neighbors_ix(i,Z)])
p= sigmoid(2*Beta*s+np.log(normal(Y[i[0],i[1]],1,sigma)/normal(Y[i[0],i[1]],-1,sigma)))
X[i[0],i[1]] = np.random.choice([1,-1],1,p = [p,1-p])
X_list = np.append(X_list,[X],axis=0)
if (n+1)%step==0:
print("iter: {}".format(n+1))
return X_list
#Importing data and initializing the parameters
data,image = read_data("../a1/4_noise.txt",True)
Y = normalize_img(image)
r,c = Y.shape
X0 = np.zeros(Y.shape)
Beta = 8
nbiter = 10
step = max(int(nbiter/100),1)
sigma = 3.5
#Image denoising
X_list = gibbs(X0,Beta,Y,sigma,nbiter)[2:]
X_avg = unnormalize_avg_img(X_list)
#Output
write_data(img_to_data(X_avg), "../outputs/a1/4_output_5.txt")
read_data("../outputs/a1/4_output_5.txt", True, save=True)
print(new_entropy)
iter_mus = mus.copy()
denoized_data = np.round(iter_mus)
denoized_data = transform_back_values(denoized_data)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data,
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt')
read_data(
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt', True, False, True)
return mus
def draw_new_samples(data):
new_data = np.zeros(data.shape)
for i in range(data.shape[0]):
for j in range(data.shape[1]):
if ((data[i, j] + 1) / 2) > np.random.rand():
new_data[i, j] = 1
return new_data
for filenumber in range(1, 5):
data, image = read_data('../a1/' + str(filenumber) + '_noise.txt', True)
data = transform_data_shape(data)
# put data in {-1, 1} space
data = transform_data_values(data)
variational_inference(data)
mask_image[:, 2] = mask * 100
foreground = np.zeros(shape=data.shape)
foreground[:, 0:2] = data[:, 0:2]
for i in range(2, 5):
foreground[:, i] = np.multiply(data[:, i], inverse_mask)
background = np.zeros(shape=data.shape)
background[:, 0:2] = data[:, 0:2]
for i in range(2, 5):
background[:, i] = np.multiply(data[:, i], mask)
return mask_image, foreground, background
if __name__ == '__main__':
values = ['fox', 'owl', 'zebra', 'cow']
for i in values:
print("Now Processing : " + str(i) + ".txt")
filename = "data" + os.sep + str(i) + ".txt"
data, image = read_data(filename, is_RGB=False)
mask, foreground, background = segment_image(data)
output_filename = "results" + os.sep + str(i) + "_mask.txt"
write_data(mask, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
output_filename = "results" + os.sep + str(i) + "_foreground.txt"
write_data(foreground, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
output_filename = "results" + os.sep + str(i) + "_background.txt"
write_data(background, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
def write_read_data(start_name, end_name, data):
# save data matrix and image into text and jpg files respectively
txt = "../output/" + start_name + "_" + end_name + ".txt"
write_data(data, txt)
jpg = "../output/" + start_name + "_" + end_name + ".jpg"
read_data(txt, False, False, True, jpg)
def expect_maxim(self, filename):
#initializing for first iteration
self.prior = [0.5, 0.5]
exp_mean1 = 0
exp_mean2 = 0
#Expectation step
log_lh = []
while (1):
self.post_sum = [0, 0]
self.posterior = [[0, 0]]
exp_mean1 = [0, 0, 0]
exp_mean2 = [0, 0, 0]
for v in self.image:
for i in v:
l_post = [0, 0]
l_post[0] = multivariate_normal.pdf(
i,
mean=self.Mean[0],
cov=self.Cov1,
allow_singular=True) # Likelihood 1
l_post[1] = multivariate_normal.pdf(
i,
mean=self.Mean[1],
cov=self.Cov2,
allow_singular=True) # Likelihood 2
l_post[0] = self.prior[0] * l_post[0]
l_post[1] = self.prior[1] * l_post[1]
Normalization = l_post[0] + l_post[1]
l_post[0] = l_post[0] / Normalization
l_post[1] = l_post[1] / Normalization
self.posterior.append(l_post)
self.post_sum[0] = self.post_sum[0] + l_post[
0] #used in the maximization step
self.post_sum[1] = self.post_sum[1] + l_post[1]
exp_mean1 = exp_mean1 + (l_post[0] * i)
exp_mean2 = exp_mean2 + (l_post[1] * i)
#Maximization Step :
self.Mean[0] = exp_mean1 / self.post_sum[0] #updated Mean
self.Mean[1] = exp_mean2 / self.post_sum[1]
variance1 = np.zeros((3, 3))
variance2 = np.zeros((3, 3))
j = 1
for v in self.image:
for i in v:
variance1 = variance1 + (self.posterior[j][0] * np.outer(
(i - self.Mean[0]), (i - self.Mean[0])))
variance2 = variance2 + (self.posterior[j][1] * np.outer(
(i - self.Mean[1]), (i - self.Mean[1])))
j = j + 1
self.Cov1 = variance1 / self.post_sum[0] #updated variance
self.Cov2 = variance2 / self.post_sum[1]
self.prior[0] = self.post_sum[0] / self.X.shape[0] #updated prior
self.prior[1] = self.post_sum[1] / self.X.shape[0]
print("Maximization ended")
lval = 0
sumList = []
for v in self.image:
for i in v:
l_post[0] = multivariate_normal.pdf(i,
self.Mean[0],
self.Cov1,
allow_singular=True)
l_post[1] = multivariate_normal.pdf(i,
self.Mean[1],
self.Cov2,
allow_singular=True)
Normalization = (self.prior[0] *
l_post[0]) + (self.prior[1] * l_post[1])
sumList.append(np.log(Normalization))
lval = np.sum(np.asarray(sumList))
log_lh.append(lval)
print("Log Likelihood: " + str(lval))
if len(log_lh) < 2: continue
if np.abs(lval - log_lh[-2]) < 0.5: break
#end of While loop
#Copying mask
backg = self.data.copy()
foreg = self.data.copy()
mask = self.data.copy()
for i in range(0, len(self.data) - 1):
cell = self.data[i]
point = [cell[2], cell[3], cell[4]]
l_post = [0, 0]
l_post[0] = multivariate_normal.pdf(
point, mean=self.Mean[0], cov=self.Cov1,
allow_singular=True) # Likelihood 1
l_post[1] = multivariate_normal.pdf(
point, mean=self.Mean[1], cov=self.Cov2,
allow_singular=True) # Likelihood 2
l_post[0] = self.prior[0] * l_post[0]
l_post[1] = self.prior[1] * l_post[1]
Normalization = l_post[0] + l_post[1]
l_post[0] = l_post[0] / Normalization
l_post[1] = l_post[1] / Normalization
if (l_post[0] < l_post[1]):
backg[i][2] = backg[i][3] = backg[i][4] = 0
mask[i][2] = mask[i][3] = mask[i][4] = 0
else:
foreg[i][2] = foreg[i][3] = foreg[i][4] = 0
mask[i][2] = 100
mask[i][3] = mask[i][4] = 0
write_data(backg, filename + "_back.txt")
read_data(filename + "_back.txt",
False,
save=True,
save_name=filename + "_background.jpg")
write_data(foreg, filename + "_fore.txt")
read_data(filename + "_fore.txt",
False,
save=True,
save_name=filename + "_foreground.jpg")
write_data(mask, filename + "_mask.txt")
read_data(filename + "_mask.txt",
False,
save=True,
save_name=filename + "_masked.jpg")
d = data.shape[-1]-2
Fgnd = data.copy()
Bgnd = data.copy()
for n in range(len(data)):
Fgnd[n,2:] = np.zeros(d) if mask[n,-1]==255 else Fgnd[n,2:]
Bgnd[n, 2:] = np.zeros(d) if mask[n, -1] == 0 else Bgnd[n, 2:]
return Fgnd,Bgnd
#Importing data and initialization
animal = "owl"
K = 2
K_epsilon = 1e-5
EM_epsilon = 1e-2
data,image = read_data("../a2/"+animal+".txt",False)
N = len(data)
d = data.shape[-1] - 2
obs_data = data[:,2:].reshape(N,d,1)
mus = np.random.randn(K,d,1)
sigmas = np.tile(np.identity(d),(K,1)).reshape(K,d,d)
pis = np.repeat(1/K,K)
#Using K-Means to provide the initial means for EM
mus,r = Kmeans(obs_data,mus,K_epsilon)
#Using EM for data segmentation (expressed in gamma)
gamma,pis,mus,sigmas = EM(obs_data,pis,mus,sigmas,EM_epsilon)
def fit_EM(m1, m2, filename, data, image):
mean1 = m1 #Mean 1
mean2 = m2 #Mean 2
eps = 0.5 #Threshold
z = np.asarray([[13, 20, 29], [13, 23, 37], [13, 23, 29]])
cov1 = np.cov(z) #covariance 1
z = np.asarray([[9, -58, 7], [8, -7, 10], [6, -4, 6]])
cov2 = np.cov(z) #covariance 2
mix1 = 0.4 #mixing co-efficient 1
mix2 = 0.6 #mixing co-efficient 2
N = image.shape[0] * image.shape[1] #Total number of samples
log_likelihoods = []
print("Initialization of mean,covariance and mixing co-efficient statement done for "+str(filename))
print("")
print("Starting EM algorithm for "+str(filename))
# Expectation Step :
iteration_number = 0
while (1):
iteration_number += 1
print("Iteration: "+str(iteration_number))
N1 = 0
N2 = 0
resp1_list = []
resp2_list = []
mu_sum1 = [0, 0, 0]
mu_sum2 = [0, 0, 0]
for y in image:
for x in y:
prob1 = pyro.sample("prob1", dist.multivariate_studentt)
prob1 = multivariate_normal.pdf(x, mean=mean1, cov=cov1, allow_singular=True) # gaussian density 1
prob2 = multivariate_normal.pdf(x, mean=mean2, cov=cov2, allow_singular=True) # gaussian density 2
Numerator1 = mix1 * prob1
Numerator2 = mix2 * prob2
denom = Numerator1 + Numerator2
resp1 = Numerator1 / denom #responsibility for 1st cluster
resp2 = Numerator2 / denom #responsibility for 2nd cluster
resp1_list.append(resp1)
resp2_list.append(resp2)
mu_sum1 += resp1 * x
mu_sum2 += resp2 * x
N1 += resp1
N2 += resp2
# Maximization Step :
mu_new1 = mu_sum1 / N1 #updated mean 1
mu_new2 = mu_sum2 / N2 #updated mean 2
var_1 = np.zeros((3, 3))
var_2 = np.zeros((3, 3))
i = 0
for y in image:
for x in y:
var_1 += resp1_list[i] * np.outer((x - mu_new1), (x - mu_new1))
var_2 += resp2_list[i] * np.outer((x - mu_new2), (x - mu_new2))
i = i + 1
var_new1 = var_1 / N1 #updated covariance1
var_new2 = var_2 / N2 #updated covariance2
mix_new1 = N1 / N #updated mixing co-efficient1
mix_new2 = N2 / N #updated mixing co-efficient2
mean1 = mu_new1
mean2 = mu_new2
cov1 = var_new1
cov2 = var_new2
mix1 = mix_new1
mix2 = mix_new2
#Calculate Log Likelihood
Z = [0, 0]
ll = 0
sumList=[]
for y in image:
for x in y:
prob1 = multivariate_normal.pdf(x, mu_new1, var_new1, allow_singular=True)
prob2 = multivariate_normal.pdf(x, mu_new2, var_new2, allow_singular=True)
sum = (mix_new1 * prob1) + (mix_new2 * prob2)
sumList.append(np.log(sum))
ll = np.sum(np.asarray(sumList))
log_likelihoods.append(ll)
print("Log Likelihood: " + str(ll))
if len(log_likelihoods) < 2: continue
if np.abs(ll - log_likelihoods[-2]) < eps: break
#Break loop if log likelihoods dont change more than threshold over 2 iterations
print("")
print("End of iterations for: " + str(filename))
print("")
#Write to File
print("Writing to file for: " + str(filename))
back_data = data.copy()
front_data = data.copy()
mask_data = data.copy()
for i in range(0,len(data)-1):
cell = data[i]
point = [cell[2], cell[3], cell[4]]
prob1 = multivariate_normal.pdf(point, mean=mean1, cov=cov1, allow_singular=True)
resp1 = mix1 * prob1
prob2 = multivariate_normal.pdf(point, mean=mean2, cov=cov2, allow_singular=True)
resp2 = mix2 * prob2
resp1 = resp1/(resp1+resp2)
resp2 = resp2/(resp1+resp2)
if (resp1 < resp2):
back_data[i][2] = back_data[i][3] = back_data[i][4] = 0
mask_data[i][2] = mask_data[i][3] = mask_data[i][4] = 0
else:
front_data[i][2] = front_data[i][3] = front_data[i][4] = 0
mask_data[i][2] = 100
mask_data[i][3] = mask_data[i][4] = 0
write_data(back_data,"../output/"+str(filename)+"_back.txt")
read_data("../output/"+str(filename)+"_back.txt", False, save=True, save_name="../output/"+str(filename)+"_background.jpg")
write_data(front_data,"../output/"+str(filename)+"_fore.txt")
read_data("../output/"+str(filename)+"_fore.txt", False, save=True, save_name="../output/"+str(filename)+"_foreground.jpg")
write_data(mask_data,"../output/"+str(filename)+"_mask.txt")
read_data("../output/"+str(filename)+"_mask.txt", False, save=True, save_name="../output/"+str(filename)+"_masked.jpg")
print("Finished writing data. Please check "+str(filename)+"_background.jpg, "+str(filename)+
"_foreground.jpg and "+str(filename)+"_masked.jpg ")
CONVERGENCE_THRESHOLD = 1
K_SEG = 2
# Place this file inside code/ folder
if __name__ == "__main__":
input_path = [
"../a2/cow.txt", "../a2/fox.txt", "../a2/owl.txt", "../a2/zebra.txt"
]
output_path = [
"../output/a2/cow", "../output/a2/fox", "../output/a2/owl",
"../output/a2/zebra"
]
for i in range(len(input_path)):
data, image = read_data(input_path[i], True)
height, width, channel = image.shape
# reshape into pixels, each has 3 channels (RGB)
pixels = image.reshape((height * width, channel))
mask, foreground, background = EM(pixels, height, width, K_SEG)
# save result images
imageplt.imsave(output_path[i] + '_mask.png', mask)
cv2.imwrite(output_path[i] + '_seg1.png',
(cv2.cvtColor(foreground, cv2.COLOR_Lab2BGR) * 255).astype(
np.uint8))
cv2.imwrite(output_path[i] + '_seg2.png',
(cv2.cvtColor(background, cv2.COLOR_Lab2BGR) * 255).astype(
np.uint8))
