-
Notifications
You must be signed in to change notification settings - Fork 0
/
generate-ifs.py
155 lines (131 loc) · 5.6 KB
/
generate-ifs.py
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
##########################################################################
## @author: silvanus david (070717) ##
## ##
## This program defines the functions needed for generating fuzzy sets ##
## from the pre-processed Image data to further use it for clustering ##
## NOTE: the program is designed to be time ineffecient inorder to ##
## manage the memory effeciency ##
##########################################################################
import os
from skfuzzy import membership
import numpy as np
import logging as log
# PRAMETERS used in the functions below are INITIALIZED here
lamda=0.1 # generate_nonmembership()
# defining all Functions necessary
def generate_fs(Image):
""" this function takes in an Image of shape (512,512) and generates fuzzy values
<Image_fs>for each pixel of the Image """
if np.shape(Image)==(512,512):
gl_max=np.amax(Image) # MAXIMUM gray level in the Image
gl_min=np.amin(Image) # MINIMUM gray level in the Image
# to store the membership values for the 2D MR Image
#Image_fs=np.zeros((512,512))
#Image_fs=(Image-glmin)/(gl_max-gl_min)
#return Image_fs
return (Image-gl_min)/(gl_max-gl_min)
else:
log.warning('shape of the Image passed to <generate_fs()> is INVALID!')
def generate_membership(Image_fs):
""" this function accepts Image and its corresponding fuzzy set and generates the membership
values for each pixel based on the input parameters"""
if np.shape(Image_fs)==(512,512):
mean=np.mean(Image_fs) # /|\ figure out hoe to calculate mean using restricted equivaleance
# /_*_\
std=np.std(Image_fs)
#Membership_value=np.zeros((512,512))
#Membership_value=0.582*((np.exp(1-abs(Image_fs-mean)))-1)
#return Membership_value
# k=abs(Image_fs-mean)
# exp=np.exp(1-k)
# val=exp-1
membership_val=membership.gaussmf(Image_fs,mean,std)
if np.amin(membership_val)<0 or np.amax(membership_val)>1:
log.warning('Value Error: membership value out of range')
else:
return membership_val
else:
log.warning('shape of the Image passed to <generate_membership()> is INVALID!')
def generate_nonmembership(Membership_value):
if np.shape(Membership_value)==(512,512):
#Nonmbership_value=np.zeros(512,512)
#Nonmbership_value=(1-Membership_value)/(1+lamda*Membership_value)
#return Nonmbership_value
nonmembership=(1-Membership_value)/(1+lamda*Membership_value)
if np.amin(nonmembership)<0 or np.amax(nonmembership)>1:
log.warning('Value Error: nonmembership value out of range')
else:
return nonmembership
else:
log.warning('shape of the Image passed to <generate_nonmembership()> is INVALID!')
def generate_hesitation(Membership_value,Nonmbership_value):
if (np.shape(Membership_value)==(512,512) and np.shape(Nonmbership_value)==(512,512)):
#Hesitation_value=(1-Membership_value-Nonmbership_value)
#return Hesitation_value
hesitation=(1-Membership_value-Nonmbership_value)
if np.amin(hesitation)<0 or np.amax(hesitation)>1:
log.warning('Value Error: hesitation value out of range')
else:
return hesitation
else:
log.warning('shape of the Image passed to <generate_hesitation()> is INVALID!')
#############################################################################
## generating an Intutionistic Fuzzy Set(IFS) for the given Images for later
## use in developing Interval Valued Intutionistic Fuzzy Set(IVFS) which are used
## in c-means clustering for detecting the tumors in the brain scans provided
#############################################################################
# PARAMETERS required are INITIALIZED here
path="/root/projects/BrainTumor/data/np_data/part_2/image_2.npy" #set this path to the numpy Image datasets stored in Image_X.npy file
fuzzy='/root/projects/BrainTumor/data/np_data/part_2/Fuzzy-values/'
# start
Image=np.load(path)
#shape=np.shape(Image)
shape=(20,512,512)
# Image_fs=generate_fs(Image[0])
# Membership_value=generate_membership(Image_fs)
# Nonmbership_value=generate_nonmembership(Membership_value)
# Hesitation_value=generate_hesitation(Membership_value,Nonmbership_value)
for turn in range(1,5):
# only create the array necessart for the particular turn
if turn==1:
print('init Image_fs')
Image_fs=np.zeros(shape)
elif turn==2:
print('init Membership')
Membership_value=np.zeros(shape)
elif turn==3:
print('init Nonmembership')
Nonmembership_value=np.zeros(shape)
elif turn==4:
print('init Hesitation')
Hesitation_value=np.zeros(shape)
print('-------------------turn :',turn,"-------------------")
example=0 #to keep a track of the current exaple in the iteration
while(example<20):
#For ach example generate on fuzzy set at each turn
print("Generating Fuzzy Values for EXAMPLE:",example)
if turn==1:
Image_fs[example]=Image_fs[example]+generate_fs(Image[example])
elif turn==2:
Membership_value[example]=Membership_value[example]+generate_membership(Image_fs[example])
elif turn==3:
Nonmembership_value[example]=Nonmembership_value[example]+generate_nonmembership(Membership_value[example])
elif turn==4:
Hesitation_value[example]=Hesitation_value[example]+generate_hesitation(Membership_value[example],Nonmembership_value[example])
example=example+1
if turn==2:
temp=fuzzy+'membership_value'
print('----------Saving MEMBERSHIP----------')
np.save(temp,Membership_value)
print('done...')
del (Image_fs)
elif turn==3:
temp=fuzzy+'nonmembership_value'
print('----------Saving NONMEMBERSHIP----------')
np.save(temp, Nonmembership_value)
print('done...')
elif turn==4:
temp=fuzzy+'hesitation_value'
print('----------Saving Hesitation----------')
np.save(temp, Hesitation_value)
print('done...')