def test_result_attributes(self):
x = np.array([
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.
])
y = np.array([
1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1.,
1., 2., 2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 2., 2., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1.
])
res = mstats.mannwhitneyu(x, y)
attributes = ('statistic', 'pvalue')
check_named_results(res, attributes, ma=True)
def check_significance(gt_dist, seg_dist):
normal_gt = normaltest(gt_dist)[1]
normal_seg = normaltest(seg_dist)[1]
# if both distributions are parametric use t-test, else use mann-whitney-u
if normal_gt > 0.05 and normal_seg > 0.05:
pvalue = ttest_ind(gt_dist, seg_dist)[1]
else:
pvalue = mannwhitneyu(gt_dist, seg_dist)[1]
if pvalue > 0.05:
return 0
if 0.01 < pvalue < 0.05:
return 1
if 0.001 < pvalue < 0.01:
return 2
if pvalue < 0.001:
return 3
return pvalue
def geneStats(scoreColumn, negArray):
scoreArray = np.ma.array(data=scoreColumn.dropna(), mask=False)
ksPval = ms.ks_twosamp(scoreArray, negArray)[1]
ksHi = ms.ks_twosamp(scoreArray, negArray, alternative = 'less')[1]
ksLo = ms.ks_twosamp(scoreArray, negArray, alternative = 'greater')[1]
if ksHi < ksLo:
ksSign = 'P'
else:
ksSign = 'S'
mwPval = ms.mannwhitneyu(scoreArray, negArray)[1]
return ksPval, ksSign, mwPval
def test_result_attributes(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])
y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])
res = mstats.mannwhitneyu(x, y)
attributes = ('statistic', 'pvalue')
check_named_results(res, attributes, ma=True)
# Determine the settings from the filename
problem, dup, ordering, nodes, mut, seed = base.split('_')
with open_file_method(filename)(filename, 'r') as f:
data = json.load(f)
version = dup, ordering, nodes, mut
if (dup, ordering) == ('skip', 'normal'):
control_group = version
statify[version].append(data[1]['evals'])
active[version].append(data[1]['phenotype'])
best = data[1]['bests'][-1]
test = data[1]['test_inputs']
individual = Individual.reconstruct_individual(best, test)
simplified = individual.new(Individual.simplify)
reduced[version].append(len(simplified.active))
filecount += 1
except ValueError:
print(filename, "FAILED")
# Kruskal's requires a rectangular matrix
rect = make_rectangular(list(statify.values()), 10000001)
print('Files Successfully Loaded', filecount)
print('Kruskal Wallis', kruskalwallis(rect))
for version, data in statify.items():
print('--------- %s ---------' % str(version))
print("MES, MAD", median_deviation(data))
print('Active', median_deviation(active[version]))
print('Reduced', median_deviation(reduced[version]))
print('Mann Whitney U against Control', end=' ')
print(mannwhitneyu(statify[control_group], data))
from scipy.stats.mstats import mannwhitneyu
st, pvalue = kruskal([x[1] for x in customers_group1],
[x[1] for x in customers_group2
]) # x[1] contains the expenditure of each product
if pvalue < 0.05:
print(
"The null hypothesis: \n\t'The average expenditure for each group is the same'\nis False"
)
# Mann-Whitney for each pair of groups. Eg.: milk_group1 - milk_group2, delicatessen_group1 - delicatessen_group2
for product in range(2, 8):
product_group1 = []
product_group2 = []
# Get the expenditures per type of product
for value in customers_group1:
product_index = data[value[0]].index(value[1])
if product_index == product:
product_group1.append(value[1])
for value in customers_group2:
product_index = data[value[0]].index(value[1])
if product_index == product:
product_group2.append(value[1])
st, pvalue = mannwhitneyu(product_group1, product_group2)
if pvalue < 0.05:
print(
"The null hypothesis: \n\t'The average income in the {} products is similar in groups 1 and 2'\nis False"
.format(real_labels[product]))
else:
print(
"The null hypothesis: \n\t'The average income in the {} products is similar in groups 1 and 2'\nis True"
.format(real_labels[product]))
def starplot(df=[],
x='',
y='',
data=[],
index=[],
columns=[],
fold=False,
foldcol=0,
mode=3,
errorbar=True,
plottype='barplot',
stats='independent t test',
test_var=False,
stats_var='f test',
crit_var=0.05,
equal_var=True,
rotate=0,
elinewidth=0.5,
fontsize=14,
capsize=4,
noffset_ylim=35,
noffset_fst=10,
noffset_diff=10,
star_size=3,
linewidth=1,
crit=[0.05, 0.01, 0.001, 0.0001]):
# data: list of data matrixs(or DataFrames) for comparison (row: obs, columns: var)
# index: var, columns: obs
# adjacent: annotate star for adjacent bar
# control: annotate star between all other bars to selctive control bar
# mix: mix mode
# 3: annotate star for all combination of bar (only 3 bars available)
crit = np.array(crit)
plt.rcParams['font.family'] = 'Times New Roman'
fig, ax = plt.subplots()
star = ['*', '**', '***', '****']
n = len(data)
m = data[0].shape[1]
test = pd.DataFrame()
for i, j in enumerate(data):
if type(test) == type(j):
data[i] = j.values.reshape(len(j.index), len(j.columns))
if plottype == 'barplot':
error = pd.DataFrame()
mean = pd.DataFrame()
for i in range(m):
error[i] = [data[j][:, i].std() for j in range(n)]
mean[i] = [data[j][:, i].mean() for j in range(n)]
error = error.transpose()
mean = mean.transpose()
if len(index) != 0:
error.index = index
mean.index = index
if len(columns) != 0:
error.columns = columns
mean.columns = columns
if fold == True:
oldmean = mean.copy()
olderror = error.copy()
for i in range(len(mean.columns)):
mean.iloc[:, i] = oldmean.iloc[:, i] / oldmean.iloc[:, foldcol]
error.iloc[:,
i] = olderror.iloc[:, i] / oldmean.iloc[:, foldcol]
if errorbar == True:
plot = plot = mean.plot.bar(yerr=error,
ax=ax,
rot=rotate,
capsize=capsize,
error_kw=dict(elinewidth=elinewidth),
fontsize=fontsize)
max_bar = [[mean.iloc[j, i] + error.iloc[j, i] for i in range(n)]
for j in range(m)]
min_bar = [
mean.iloc[j, i] - error.iloc[j, i] for i in range(n)
for j in range(m)
]
else:
plot = plot = mean.plot.bar(ax=ax,
rot=rotate,
capsize=capsize,
error_kw=dict(elinewidth=elinewidth),
fontsize=fontsize)
max_bar = [[mean.iloc[j, i] for i in range(n)] for j in range(m)]
min_bar = [mean.iloc[j, i] for i in range(n) for j in range(m)]
elif plottype == 'boxplot':
print("under buiding")
ylim = 0
offset = max([max_bar[i][j] for i in range(m) for j in range(n)]) / 100
blank = []
if mode == 3:
for j in range(m):
level = np.zeros(n)
for i in range(n):
if i < n - 1:
k = i + 1
else:
k = 0
if test_var == True:
if stats_var == 'f test':
f = 0.5 - abs(0.5 - ftest.sf(
data[i][:, j].var() / data[k][:, j].var(),
len(data[i][:, j]) - 1,
len(data[k][:, j]) - 1))
if crit_var / 2 > f:
equal_var = False
else:
equal_var = True
else:
if stats_var == 'bartlett':
f = bartlett(data[i][:, j], data[k][:, j])[1]
elif stats_var == 'levene':
f = bartlett(data[i][:, j], data[k][:, j])[1]
elif stats_var == 'fligner':
f = fligner(data[i][:, j], data[k][:, j])[1]
if crit_var > f:
equal_var = False
else:
equal_var = True
if stats == 'independent t test':
p = ttest_ind(data[i][:, j],
data[k][:, j],
equal_var=equal_var)[1]
elif stats == 'paired t test':
if equal_var == True:
p = ttest_rel(data[i][:, j], data[k][:, j])[1]
else:
p = 0
elif stats == 'median test':
p = median_test(data[i][:, j], data[k][:, j])[1]
elif stats == 'mannwhitneyu':
if equal_var == True:
p = mannwhitneyu(data[i][:, j], data[k][:, j])[1]
else:
p = 0
elif stats == 'wilcoxon':
if equal_var == True:
p = wilcoxon(data[i][:, j], data[k][:, j])[1]
else:
p = 0
level[i] = len(crit) - len(crit.compress(p > crit))
for k in range(n):
height = 0
if level[k] != 0 and k != n - 1:
center = [
plot.patches[k * m + j].get_x(),
plot.patches[k * m + m + j].get_x()
]
height = max([max_bar[j][k], max_bar[j][k + 1]])
h1 = max_bar[j][k]
h2 = max_bar[j][k + 1]
width = plot.patches[k * m + j].get_width()
blank.append(
(center[0] + width / 2,
height + noffset_fst * offset + (-1)**k * 2 * offset))
blank.append(
(center[1] + width / 2,
height + noffset_fst * offset + (-1)**k * 2 * offset))
ax.vlines(x=center[0] + width / 2,
ymin=h1 + offset * 2,
ymax=height + noffset_fst * offset +
(-1)**k * 2 * offset,
lw=linewidth)
ax.vlines(x=center[1] + width / 2,
ymin=h2 + offset * 2,
ymax=height + noffset_fst * offset +
(-1)**k * 2 * offset,
lw=linewidth)
ax.annotate(star[int(level[k] - 1)],
xy=((center[0] + center[1]) / 2 + width / 2,
height + (noffset_fst + 1) * offset +
(-1)**k * 2 * offset),
ha='center',
size=star_size)
elif level[k] != 0 and k == n - 1:
center = [
plot.patches[j].get_x(),
plot.patches[k * m + j].get_x()
]
height = max(max_bar[j])
h1 = max_bar[j][0]
h2 = max_bar[j][k]
blank.append(
(center[0] + width / 2,
height + (noffset_fst + noffset_diff) * offset))
blank.append((center[1] + width / 2, height + 20 * offset))
ax.vlines(x=center[0] + width / 2,
ymin=h1 + offset * 2,
ymax=height +
(noffset_fst + noffset_diff) * offset,
lw=linewidth)
ax.vlines(x=center[1] + width / 2,
ymin=h2 + offset * 2,
ymax=height +
(noffset_fst + noffset_diff) * offset,
lw=linewidth)
ax.annotate(star[int(level[k] - 1)],
xy=((center[0] + center[1]) / 2 + width / 2,
height +
(noffset_fst + noffset_diff + 1) * offset),
ha='center',
size=star_size)
if height > ylim:
ylim = height
if mode == 'adjacent':
for j in range(m):
level = np.zeros(n - 1)
for i in range(n - 1):
k = i + 1
if test_var == True:
if stats_var == 'f test':
f = 0.5 - abs(0.5 - ftest.sf(
data[i][:, j].var() / data[k][:, j].var(),
len(data[i][:, j]) - 1,
len(data[k][:, j]) - 1))
if crit_var / 2 > f:
equal_var = False
else:
equal_var = True
else:
if stats_var == 'bartlett':
f = bartlett(data[i][:, j], data[k][:, j])[1]
elif stats_var == 'levene':
f = bartlett(data[i][:, j], data[k][:, j])[1]
elif stats_var == 'fligner':
f = fligner(data[i][:, j], data[k][:, j])[1]
if crit_var > f:
equal_var = False
else:
equal_var = True
if stats == 'independent t test':
p = ttest_ind(data[i][:, j],
data[k][:, j],
equal_var=equal_var)[1]
elif stats == 'paired t test':
if equal_var == True:
p = ttest_rel(data[i][:, j], data[k][:, j])[1]
else:
p = 0
elif stats == 'median test':
p = median_test(data[i][:, j], data[k][:, j])[1]
elif stats == 'mannwhitneyu':
if equal_var == True:
p = mannwhitneyu(data[i][:, j], data[k][:, j])[1]
else:
p = 0
elif stats == 'wilcoxon':
if equal_var == True:
p = wilcoxon(data[i][:, j], data[k][:, j])[1]
else:
p = 0
level[i] = len(crit) - len(crit.compress(p > crit))
for k in range(n - 1):
height = 0
if level[k] != 0:
center = [
plot.patches[k * m + j].get_x(),
plot.patches[k * m + m + j].get_x()
]
height = max([max_bar[j][k], max_bar[j][k + 1]])
h1 = max_bar[j][k]
h2 = max_bar[j][k + 1]
width = plot.patches[k * m + j].get_width()
blank.append(
(center[0] + width / 2,
height + noffset_fst * offset + (-1)**k * 2 * offset))
blank.append(
(center[1] + width / 2,
height + noffset_fst * offset + (-1)**k * 2 * offset))
ax.vlines(x=center[0] + width / 2,
ymin=h1 + offset * 2,
ymax=height + noffset_fst * offset +
(-1)**k * 2 * offset,
lw=linewidth)
ax.vlines(x=center[1] + width / 2,
ymin=h2 + offset * 2,
ymax=height + noffset_fst * offset +
(-1)**k * 2 * offset,
lw=linewidth)
ax.annotate(star[int(level[k] - 1)],
xy=((center[0] + center[1]) / 2 + width / 2,
height + (noffset_fst + 1) * offset +
(-1)**k * 2 * offset),
ha='center',
size=star_size)
if height > ylim:
ylim = height
ax.set_ylim(min(0,
min(min_bar) - 10 * offset), ylim + noffset_ylim * offset)
for j, i in enumerate(blank):
ax.vlines(x=i[0],
ymin=i[1],
ymax=i[1] + offset * 2,
color='white',
lw=1.2 * linewidth)
if j % 2 == 1:
ax.hlines(y=i[1], xmin=blank[j - 1], xmax=blank[j], lw=linewidth)
print("\n")
#"""
print(normaltest(all_data["Gaussian"])[1])
print(normaltest(all_data["Hessian"])[1])
print(normaltest(all_data["Laplacian"])[1])
print(normaltest(all_data["Ilastik"])[1])
print(normaltest(all_data["MitoSegNet"])[1])
print(normaltest(all_data["Finetuned\nFiji U-Net"])[1])
#print(normaltest(all_data["Fiji U-Net"])[1])
#"""
print("\n")
print(mannwhitneyu(all_data["Gaussian"], all_data["MitoSegNet"])[1])
print(mannwhitneyu(all_data["Hessian"], all_data["MitoSegNet"])[1])
print(mannwhitneyu(all_data["Laplacian"], all_data["MitoSegNet"])[1])
print(mannwhitneyu(all_data["Ilastik"], all_data["MitoSegNet"])[1])
print(
mannwhitneyu(all_data["Finetuned\nFiji U-Net"], all_data["MitoSegNet"])[1])
#print(mannwhitneyu(all_data["Fiji U-Net"], all_data["MitoSegNet"])[1])
p_g = mannwhitneyu(all_data["Gaussian"], all_data["MitoSegNet"])[1]
p_h = mannwhitneyu(all_data["Hessian"], all_data["MitoSegNet"])[1]
p_l = mannwhitneyu(all_data["Laplacian"], all_data["MitoSegNet"])[1]
p_i = mannwhitneyu(all_data["Ilastik"], all_data["MitoSegNet"])[1]
p_f = mannwhitneyu(all_data["Finetuned\nFiji U-Net"],
all_data["MitoSegNet"])[1]
def u_stat_all_label(data, ts=None, labels=None, mask=None):
"""
Calculate the U-statistic for all label pairings in a HCTSA_loc.mat file. The operations can be masked
by a boolean array.
Parameters:
-----------
ts : dict, optional (either labels or ts has to be given)
'TimeSeries' dictionary from HCTSA_loc.mat file.
labels : ndarray, optional (either labels or ts has to be given)
An array containing the label for each timeseries (row) in data.
data : ndarray
data array where each row represents a timeseries and each column represents a feature
mask : ndarray dtype='bool', optional
If given this acts as mask to which features are included in the calculation
Returns:
--------
ranks : ndarray of dim (n_labels * (n_labels-1) / 2, nr_features)
The U-statistic for all features and label pairs, where a row represents a pair of labels.
Every column represents one feature.
labels_unique : list
List of all unique labels
label_ind_list : list
List of lists where each sub-list i represents all row-indices in data containing timeseries
for labels_unique[i]
"""
# ---------------------------------------------------------------------
# mask the data if required
# ---------------------------------------------------------------------
if mask != None:
data = data[:,mask]
# ---------------------------------------------------------------------
# extract the unique labels
# ---------------------------------------------------------------------
if labels == None:
# FIXME this is only in to secure compatibility to previous versions
if ts != None:
labels = [x.split(',')[0] for x in ts['keywords']]
else:
# FIXME some error handling would be good
exit()
labels_unique = list(set(labels))
# FIXME Not sure if this is necessary or why it is there in the first place
labels = np.array(labels,dtype = np.dtype('S64'))
label_ind_list = []
# ---------------------------------------------------------------------
# get indices for all unique labels
# ---------------------------------------------------------------------
for i,label in enumerate(labels_unique):
label_ind_list.append(np.nonzero((labels == label))[0])
n_labels = len(label_ind_list)
# ---------------------------------------------------------------------
# calculate Mann-Whitney u-test
# ---------------------------------------------------------------------
ranks = np.zeros((n_labels * (n_labels-1) / 2,data.shape[1]))
norm = np.zeros(n_labels * (n_labels-1) / 2)
for i,(label_ind_0,label_ind_1) in enumerate(itertools.combinations(range(n_labels),2)):
data_0 = data[label_ind_list[label_ind_0],:]
data_1 = data[label_ind_list[label_ind_1],:]
print "calculating label pair {:d} / {:d}".format(i+1,n_labels * (n_labels-1) / 2)
for k in range(0,data.shape[1]):
if np.ma.all((data_0[:,k] == data_0[0,k])) and np.ma.all((data_1[:,k] == data_0[0,k] )):
ranks[i,k] = data_0[:,k].shape[0] * data_1[:,k].shape[0]/2.
else:
ranks[i,k] = stats.mannwhitneyu(data_0[:,k], data_1[:,k])[0]
# -- Calculate the norm factor for every label pair
norm[i] = data_0.shape[0] * data_1.shape[0]
return ranks, norm, labels_unique, label_ind_list
def morph_distribution(path, seg_name):
gt_folder_path = path + os.sep + "Ground_Truth"
seg_folder_path = path + os.sep + seg_name
org_folder_path = path + os.sep + "Original"
#image_list = os.listdir(gt_folder_path)
image_list = ["170412 MD4049 w10 FL200.tif"]
columns = ["Image", "Area", "Eccentricity", "Aspect Ratio", "Perimeter", "Solidity", "Number of branches",
"Branch length", "Total branch length", "Curvature index", "Mean intensity"]
df = pd.DataFrame(columns=columns)
df_2 = pd.DataFrame(columns=columns)
df_c = pd.DataFrame(columns=columns)
list_area = []
list_ecc = []
list_ar = []
list_per = []
list_sol = []
list_nb = []
list_tbl = []
list_bl = []
list_ci = []
list_int = []
clist_area = []
clist_ecc = []
clist_ar = []
clist_per = []
clist_sol = []
clist_nb = []
clist_tbl = []
clist_bl = []
clist_ci = []
clist_int = []
elist_area = []
elist_ecc = []
elist_ar = []
elist_per = []
elist_sol = []
elist_nb = []
elist_tbl = []
elist_bl = []
elist_ci = []
elist_int = []
###################################################
###################################################
for image in image_list:
print(image)
gt = cv2.imread(gt_folder_path + os.sep + image, cv2.IMREAD_GRAYSCALE)
seg = cv2.imread(seg_folder_path + os.sep + image , cv2.IMREAD_GRAYSCALE)
org = cv2.imread(org_folder_path + os.sep + image, cv2.IMREAD_GRAYSCALE)
# skeletonize
##################################################
##################################################
def get_branch_meas(path):
"""
05-07-19
for some reason the sumarise function of skan prints out a different number of objects, which is why
i currently cannot include the branch data in the same table as the morph parameters
"""
read_lab_skel = img_as_bool(color.rgb2gray(io.imread(path)))
lab_skel = skeletonize(read_lab_skel).astype("uint8")
branch_data = summarise(lab_skel)
# curv_ind = (branch_data["branch-distance"] - branch_data["euclidean-distance"]) / branch_data["euclidean-distance"]
curve_ind = []
for bd, ed in zip(branch_data["branch-distance"], branch_data["euclidean-distance"]):
if ed != 0.0:
curve_ind.append((bd - ed) / ed)
else:
curve_ind.append(bd - ed)
branch_data["curvature-index"] = curve_ind
grouped_branch_data_mean = branch_data.groupby(["skeleton-id"], as_index=False).mean()
grouped_branch_data_sum = branch_data.groupby(["skeleton-id"], as_index=False).sum()
counter = collections.Counter(branch_data["skeleton-id"])
n_branches = []
for i in grouped_branch_data_mean["skeleton-id"]:
n_branches.append(counter[i])
branch_len = grouped_branch_data_mean["branch-distance"].tolist()
tot_branch_len = grouped_branch_data_sum["branch-distance"].tolist()
curv_ind = grouped_branch_data_mean["curvature-index"].tolist()
return n_branches, branch_len, tot_branch_len, curv_ind
def significance(pvalue):
if pvalue > 0.05:
return 0
if 0.01 < pvalue < 0.05:
return 1
if 0.001 < pvalue < 0.01:
return 2
if pvalue < 0.001:
return 3
return pvalue
# pooled standard deviation for calculation of effect size (cohen's d)
def cohens_d(data1, data2):
p_std = np.sqrt(
((len(data1) - 1) * np.var(data1) + (len(data2) - 1) * np.var(data2)) / (len(data1) + len(data2) - 2))
cohens_d = np.abs(np.median(data1) - np.median(data2)) / p_std
return cohens_d
##################################################
##################################################
gt_nb, gt_bl, gt_tbl, gt_ci = get_branch_meas(gt_folder_path + os.sep + image)
seg_nb, seg_bl, seg_tbl, seg_ci = get_branch_meas(seg_folder_path + os.sep + image)
#######################
pvalue_nb = mannwhitneyu(gt_nb, seg_nb)[1]
list_nb.append(significance(pvalue_nb))
elist_nb.append(energy_distance(gt_nb, seg_nb))
clist_nb.append(cohens_d(gt_nb, seg_nb))
pvalue_bl = mannwhitneyu(gt_bl, seg_bl)[1]
list_bl.append(significance(pvalue_bl))
elist_bl.append(energy_distance(gt_bl, seg_bl))
clist_bl.append(cohens_d(gt_bl, seg_bl))
pvalue_tbl = mannwhitneyu(gt_tbl, seg_tbl)[1]
list_tbl.append(significance(pvalue_tbl))
elist_tbl.append(energy_distance(gt_tbl, seg_tbl))
clist_tbl.append(cohens_d(gt_tbl, seg_tbl))
pvalue_ci = mannwhitneyu(gt_ci, seg_ci)[1]
list_ci.append(significance(pvalue_ci))
elist_ci.append(energy_distance(gt_ci, seg_ci))
clist_ci.append(cohens_d(gt_ci, seg_ci))
#######################
# label image mask
gt_labelled = label(gt)
seg_labelled = label(seg)
# Get region props of labelled images
gt_reg_props = regionprops(label_image=gt_labelled, intensity_image=org, coordinates='xy')
seg_reg_props = regionprops(label_image=seg_labelled, intensity_image=org, coordinates='xy')
# compare shape descriptor distributions
#################################
# Intensity
gt_int = [i.mean_intensity for i in gt_reg_props]
seg_int = [i.mean_intensity for i in seg_reg_props]
pvalue_int = mannwhitneyu(gt_int, seg_int)[1]
list_int.append(significance(pvalue_int))
elist_int.append(energy_distance(gt_int, seg_int))
clist_int.append(cohens_d(gt_int, seg_int))
# Area
gt_area = [i.area for i in gt_reg_props]
seg_area = [i.area for i in seg_reg_props]
pvalue_area = mannwhitneyu(gt_area, seg_area)[1]
list_area.append(significance(pvalue_area))
#list_area.append(pvalue_area)
#list_area2.append(cohens_d(gt_area, seg_area))
elist_area.append(energy_distance(gt_area, seg_area))
clist_area.append(cohens_d(gt_area, seg_area))
# Eccentricity
gt_ecc = [i.eccentricity for i in gt_reg_props]
seg_ecc = [i.eccentricity for i in seg_reg_props]
pvalue_ecc = mannwhitneyu(gt_ecc, seg_ecc)[1]
list_ecc.append(significance(pvalue_ecc))
#list_ecc.append(pvalue_ecc)
#list_ecc2.append(cohens_d(gt_ecc, seg_ecc))
elist_ecc.append(energy_distance(gt_ecc, seg_ecc))
clist_ecc.append(cohens_d(gt_ecc, seg_ecc))
# Aspect ratio
gt_ar = [i.major_axis_length/i.minor_axis_length for i in gt_reg_props if i.minor_axis_length != 0]
seg_ar = [i.major_axis_length/i.minor_axis_length for i in seg_reg_props if i.minor_axis_length != 0]
pvalue_ar = mannwhitneyu(gt_ar, seg_ar)[1]
list_ar.append(significance(pvalue_ar))
#list_ar.append(pvalue_ar)
#list_ar2.append(cohens_d(gt_ar, seg_ar))
elist_ar.append(energy_distance(gt_ar, seg_ar))
clist_ar.append(cohens_d(gt_ar, seg_ar))
# Perimeter
gt_per = [i.perimeter for i in gt_reg_props]
seg_per = [i.perimeter for i in seg_reg_props]
pvalue_per = mannwhitneyu(gt_per, seg_per)[1]
list_per.append(significance(pvalue_per))
#list_per.append(pvalue_per)
#list_per2.append(cohens_d(gt_per, seg_per))
elist_per.append(energy_distance(gt_per, seg_per))
clist_per.append(cohens_d(gt_per, seg_per))
# Solidity
gt_sol = [i.solidity for i in gt_reg_props]
seg_sol = [i.solidity for i in seg_reg_props]
#print(len(gt_sol))
pvalue_sol = mannwhitneyu(gt_sol, seg_sol)[1]
list_sol.append(significance(pvalue_sol))
#list_sol.append(pvalue_sol)
#list_sol2.append(cohens_d(gt_sol, seg_sol))
elist_sol.append(energy_distance(gt_sol, seg_sol))
clist_sol.append(cohens_d(gt_sol, seg_sol))
#################################
columns = ["Image", "Area", "Eccentricity", "Aspect Ratio", "Perimeter", "Solidity", "Number of branches",
"Branch length", "Total branch length", "Curvature index", "Mean Intensity"]
df["Image"] = image_list
df["Area"] = list_area
df["Eccentricity"] = list_ecc
df["Aspect Ratio"] = list_ar
df["Perimeter"] = list_per
df["Solidity"] = list_sol
df["Number of branches"] = list_nb
df["Branch length"] = list_bl
df["Total branch length"] = list_tbl
df["Curvature index"] = list_ci
df["Mean intensity"] = list_int
df_2["Image"] = image_list
df_2["Area"] = elist_area
df_2["Eccentricity"] = elist_ecc
df_2["Aspect Ratio"] = elist_ar
df_2["Perimeter"] = elist_per
df_2["Solidity"] = elist_sol
df_2["Number of branches"] = elist_nb
df_2["Branch length"] = elist_bl
df_2["Total branch length"] = elist_tbl
df_2["Curvature index"] = elist_ci
df_2["Mean intensity"] = elist_int
df_2["Image"] = image_list
df_c["Area"] = clist_area
df_c["Eccentricity"] = clist_ecc
df_c["Aspect Ratio"] = clist_ar
df_c["Perimeter"] = clist_per
df_c["Solidity"] = clist_sol
df_c["Number of branches"] = clist_nb
df_c["Branch length"] = clist_bl
df_c["Total branch length"] = clist_tbl
df_c["Curvature index"] = clist_ci
df_c["Mean intensity"] = clist_int
#total_values = len(image_list)*5
zero_p = 0
one_p = 0
two_p = 0
three_p = 0
for index, row in df.iterrows():
for column in row:
if column == 0:
zero_p+=1
elif column == 1:
one_p+=1
elif column == 2:
two_p+=1
elif column == 3:
three_p+=1
#print(zero_p/total_values)
#print(one_p/total_values)
#print(two_p/total_values)
#print(three_p/total_values)
# raw data
df.to_csv(path + os.sep + seg_name + "_Morph_Dist_comparison.csv")
df_2.to_csv(path + os.sep + seg_name + "_EnergyDistance.csv")
df_c.to_csv(path + os.sep + seg_name + "_EffectSize.csv")
print("\n")
#"""
print(normaltest(h_l)[1])
print(normaltest(la_l)[1])
print(normaltest(ga_l)[1])
print(normaltest(il_l)[1])
print(normaltest(m_l)[1])
print(normaltest(u_l_pt)[1])
#"""
#print(normaltest(u_l)[1])
print("\n")
print(mannwhitneyu(m_l, h_l)[1])
print(mannwhitneyu(m_l, la_l)[1])
print(mannwhitneyu(m_l, ga_l)[1])
print(mannwhitneyu(m_l, il_l)[1])
print(mannwhitneyu(m_l, u_l_pt)[1])
#print(mannwhitneyu(m_l, u_l)[1])
"""
all_data["Gaussian"] = ga_l
all_data["Hessian"] = h_l
all_data["Laplacian"] = la_l
all_data["Ilastik"] = il_l
all_data["MitoSegNet"] = m_l
all_data["Finetuned\nFiji U-Net"] = u_l_pt
"""
print(normaltest(data["Gaussian"].dropna())[1])
print(normaltest(data["Laplacian"].dropna())[1])
print(normaltest(data["Hessian"].dropna())[1])
print(normaltest(data["Ilastik"].dropna())[1])
print(normaltest(data["MitoSegNet"].dropna())[1])
"""
print(len(data["Gaussian"].dropna()))
print(len(data["Laplacian"].dropna()))
print(len(data["Hessian"].dropna()))
print(len(data["Ilastik"].dropna()))
print(len(data["MitoSegNet"].dropna()))
print("\n")
print(mannwhitneyu(mitonet, hess)[1])
print(mannwhitneyu(mitonet, gauss)[1])
print(mannwhitneyu(mitosegnet, lap)[1])
print(mannwhitneyu(mitosegnet, il)[1])
# pooled standard deviation for calculation of effect size (cohen's d)
def cohens_d(data1, data2):
p_std = np.sqrt(
((len(data1) - 1) * np.var(data1) +
(len(data2) - 1) * np.var(data2)) / (len(data1) + len(data2) - 2))
cohens_d = np.abs(np.average(data1) - np.average(data2)) / p_std
return cohens_d
def u_stat_all_label_file_name(file_name, mask=None, is_from_old_matlab=False):
"""
Calculate the U-statistic for all label pairings in a HCTSA_loc.mat file. The operations can be masked
by a boolean array.
Parameters:
-----------
file_name : string
File name of the HCTSA_loc.mat file containing as least the matrices 'TimeSeries' and 'TS_DataMat'
mask : ndarray dtype='bool', optional
If given this acts as mask to which features are included in the calculation
is_from_old_matlab : bool
If the HCTSA_loc.mat files are saved from an older version of the comp engine. The order of entries is different.
Returns:
--------
ranks : ndarray of dim (n_labels * (n_labels-1) / 2, nr_timeseries)
The U-statistic for all features and label pairs, where a row represents a pair of labels.
Every column represents one feature
labels_unique : list
List of all unique labels
label_ind_list : list
List of lists where each sub-list i represents all row-indices in data containing timeseries
for labels_unique[i]
"""
# ---------------------------------------------------------------------
# load the data
# ---------------------------------------------------------------------
ts, data = mIO.read_from_mat_file(file_name, ['TimeSeries', 'TS_DataMat'],
is_from_old_matlab=is_from_old_matlab)
# ---------------------------------------------------------------------
# mask the data if required
# ---------------------------------------------------------------------
if mask != None:
data = data[:, mask]
# ---------------------------------------------------------------------
# extract the unique labels
# ---------------------------------------------------------------------
labels = [int(x.split(',')[-1]) for x in ts['keywords']]
labels_unique = list(set(labels))
labels = np.array(labels)
label_ind_list = []
# ---------------------------------------------------------------------
# get indices for all unique labels
# ---------------------------------------------------------------------
for i, label in enumerate(labels_unique):
label_ind_list.append(np.nonzero((labels == label))[0])
n_labels = len(label_ind_list)
# ---------------------------------------------------------------------
# calculate Mann-Whitney u-test
# ---------------------------------------------------------------------
ranks = np.zeros((n_labels * (n_labels - 1) / 2, data.shape[1]))
for i, (label_ind_0, label_ind_1) in enumerate(
itertools.combinations(range(n_labels), 2)):
# -- select the data for the current labels
data_0 = data[label_ind_list[label_ind_0], :]
data_1 = data[label_ind_list[label_ind_1], :]
print i + 1, '/', n_labels * (n_labels - 1) / 2
for k in range(0, data.shape[1]):
# -- in the case of same value for every feature in both arrays set max possible value
if np.ma.all((data_0[:, k] == data_0[0, k])) and np.ma.all(
(data_1[:, k] == data_0[0, k])):
ranks[i,
k] = data_0[:, k].shape[0] * data_1[:, k].shape[0] / 2.
else:
ranks[i, k] = stats.mannwhitneyu(data_0[:, k], data_1[:, k])[0]
return ranks, labels_unique, label_ind_list
def u_stat_all_label(data, ts=None, labels=None, mask=None):
"""
Calculate the U-statistic for all label pairings in a HCTSA_loc.mat file. The operations can be masked
by a boolean array.
Parameters:
-----------
ts : dict, optional (either labels or ts has to be given)
'TimeSeries' dictionary from HCTSA_loc.mat file.
labels : ndarray, optional (either labels or ts has to be given)
An array containing the label for each timeseries (row) in data.
data : ndarray
data array where each row represents a timeseries and each column represents a feature
mask : ndarray dtype='bool', optional
If given this acts as mask to which features are included in the calculation
Returns:
--------
ranks : ndarray of dim (n_labels * (n_labels-1) / 2, nr_features)
The U-statistic for all features and label pairs, where a row represents a pair of labels.
Every column represents one feature.
labels_unique : list
List of all unique labels
label_ind_list : list
List of lists where each sub-list i represents all row-indices in data containing timeseries
for labels_unique[i]
"""
# ---------------------------------------------------------------------
# mask the data if required
# ---------------------------------------------------------------------
if mask != None:
data = data[:, mask]
# ---------------------------------------------------------------------
# extract the unique labels
# ---------------------------------------------------------------------
if labels == None:
# FIXME this is only in to secure compatibility to previous versions
if ts != None:
labels = [x.split(',')[0] for x in ts['keywords']]
else:
# FIXME some error handling would be good
exit()
labels_unique = list(set(labels))
# FIXME Not sure if this is necessary or why it is there in the first place
labels = np.array(labels, dtype=np.dtype('S64'))
label_ind_list = []
# ---------------------------------------------------------------------
# get indices for all unique labels
# ---------------------------------------------------------------------
for i, label in enumerate(labels_unique):
label_ind_list.append(np.nonzero((labels == label))[0])
n_labels = len(label_ind_list)
# ---------------------------------------------------------------------
# calculate Mann-Whitney u-test
# ---------------------------------------------------------------------
ranks = np.zeros((n_labels * (n_labels - 1) / 2, data.shape[1]))
norm = np.zeros(n_labels * (n_labels - 1) / 2)
for i, (label_ind_0, label_ind_1) in enumerate(
itertools.combinations(range(n_labels), 2)):
data_0 = data[label_ind_list[label_ind_0], :]
data_1 = data[label_ind_list[label_ind_1], :]
print "calculating label pair {:d} / {:d}".format(
i + 1,
n_labels * (n_labels - 1) / 2)
for k in range(0, data.shape[1]):
if np.ma.all((data_0[:, k] == data_0[0, k])) and np.ma.all(
(data_1[:, k] == data_0[0, k])):
ranks[i,
k] = data_0[:, k].shape[0] * data_1[:, k].shape[0] / 2.
else:
ranks[i, k] = stats.mannwhitneyu(data_0[:, k], data_1[:, k])[0]
# -- Calculate the norm factor for every label pair
norm[i] = data_0.shape[0] * data_1.shape[0]
return ranks, norm, labels_unique, label_ind_list
89.69072164948453, 96.907216494845358, 92.783505154639172, 95.876288659793815, 98.969072164948457]\
])
############### Tool's MAX.ACC PER CORPUS #################
#max_accs_array = np.array([ [ 95.26, 95.56, 95.70, 95.18, 95.85, 98.13, 94.88, 94.12 ],\
# [ 91.53, 90.84, 89.16, 90.23, 91.03, 91.99, 87.09, 90.81 ],\
# [ 91.47, 92.00, 91.73, 92.27, 90.67, 87.43, 88.27, 91.23 ],\
# [ 92.00, 93.60, 92.27, 93.33, 92.27, 95.27, 89.33, 92.57 ],\
# ])
print spm.kruskalwallis(max_accs_array[0],max_accs_array[1],max_accs_array[2],max_accs_array[3],\
max_accs_array[4],max_accs_array[6],max_accs_array[7])
print spm.kruskalwallis(max_accs_array[5],max_accs_array[2])
#print sps.wilcoxon(max_accs_array[1],max_accs_array[4])
print spm.mannwhitneyu(max_accs_array[5],max_accs_array[2]) #, use_continuity=True)
0/0
#print max_accs_array
#import matplotlib.pyplot as plt
#plt.hist(max_accs_array[1], 10) #bins, range, normed, weights, cumulative, bottom, histtype, align, orientation, rwidth, log, hold))
#plt.figure()
#plt.plot([1,2,3,4,5,6,7,8,9,10],max_accs_array[7] ) #, histtype='bar', rwidth=0.8)
#plt.show()
print max_accs_array, "\n"
max_accs_vect = max_accs_array.copy()
#max_accs_vect = max_accs_vect.reshape(1,80)
max_accs_vect = max_accs_vect.reshape(1,32)
def u_stat_all_label_file_name(file_name,mask = None, is_from_old_matlab=False):
"""
Calculate the U-statistic for all label pairings in a HCTSA_loc.mat file. The operations can be masked
by a boolean array.
Parameters:
-----------
file_name : string
File name of the HCTSA_loc.mat file containing as least the matrices 'TimeSeries' and 'TS_DataMat'
mask : ndarray dtype='bool', optional
If given this acts as mask to which features are included in the calculation
is_from_old_matlab : bool
If the HCTSA_loc.mat files are saved from an older version of the comp engine. The order of entries is different.
Returns:
--------
ranks : ndarray of dim (n_labels * (n_labels-1) / 2, nr_timeseries)
The U-statistic for all features and label pairs, where a row represents a pair of labels.
Every column represents one feature
labels_unique : list
List of all unique labels
label_ind_list : list
List of lists where each sub-list i represents all row-indices in data containing timeseries
for labels_unique[i]
"""
# ---------------------------------------------------------------------
# load the data
# ---------------------------------------------------------------------
ts,data = mIO.read_from_mat_file(file_name,['TimeSeries','TS_DataMat'],is_from_old_matlab = is_from_old_matlab )
# ---------------------------------------------------------------------
# mask the data if required
# ---------------------------------------------------------------------
if mask != None:
data = data[:,mask]
# ---------------------------------------------------------------------
# extract the unique labels
# ---------------------------------------------------------------------
labels = [int(x.split(',')[-1]) for x in ts['keywords']]
labels_unique = list(set(labels))
labels = np.array(labels)
label_ind_list = []
# ---------------------------------------------------------------------
# get indices for all unique labels
# ---------------------------------------------------------------------
for i,label in enumerate(labels_unique):
label_ind_list.append(np.nonzero((labels == label))[0])
n_labels = len(label_ind_list)
# ---------------------------------------------------------------------
# calculate Mann-Whitney u-test
# ---------------------------------------------------------------------
ranks = np.zeros((n_labels * (n_labels-1) / 2,data.shape[1]))
for i,(label_ind_0,label_ind_1) in enumerate(itertools.combinations(range(n_labels),2)):
# -- select the data for the current labels
data_0 = data[label_ind_list[label_ind_0],:]
data_1 = data[label_ind_list[label_ind_1],:]
print i+1,'/',n_labels * (n_labels-1) / 2
for k in range(0,data.shape[1]):
# -- in the case of same value for every feature in both arrays set max possible value
if np.ma.all((data_0[:,k] == data_0[0,k])) and np.ma.all((data_1[:,k] == data_0[0,k] )):
ranks[i,k] = data_0[:,k].shape[0] * data_1[:,k].shape[0]/2.
else:
ranks[i,k] = stats.mannwhitneyu(data_0[:,k], data_1[:,k])[0]
return ranks,labels_unique,label_ind_list
# Determine the settings from the filename
problem, dup, ordering, nodes, mut, seed = base.split('_')
with open_file_method(filename)(filename, 'r') as f:
data = json.load(f)
version = dup, ordering, nodes, mut
if (dup, ordering) == ('skip', 'normal'):
control_group = version
statify[version].append(data[1]['evals'])
active[version].append(data[1]['phenotype'])
best = data[1]['bests'][-1]
test = data[1]['test_inputs']
individual = Individual.reconstruct_individual(best, test)
simplified = individual.new(Individual.simplify)
reduced[version].append(len(simplified.active))
filecount += 1
except ValueError:
print filename, "FAILED"
# Kruskal's requires a rectangular matrix
rect = make_rectangular(statify.values(), 10000001)
print 'Files Successfully Loaded', filecount
print 'Kruskal Wallis', kruskalwallis(rect)
for version, data in statify.iteritems():
print '--------- %s ---------' % str(version)
print "MES, MAD", median_deviation(data)
print 'Active', median_deviation(active[version])
print 'Reduced', median_deviation(reduced[version])
print 'Mann Whitney U against Control',
print mannwhitneyu(statify[control_group], data)
def morph_distribution(path, seg_name):
gt_folder_path = path + "Ground_Truth"
seg_folder_path = path + seg_name
gt_image_list = os.listdir(gt_folder_path)
seg_image_list = os.listdir(seg_folder_path)
columns = ["Image", "Area", "Eccentricity", "Aspect Ratio", "Perimeter", "Solidity"]
df = pd.DataFrame(columns=columns)
df_2 = pd.DataFrame(columns=columns)
list_area = []
list_ecc = []
list_ar = []
list_per = []
list_sol = []
list_area2 = []
list_ecc2 = []
list_ar2 = []
list_per2 = []
list_sol2 = []
def significance(pvalue):
#"""
if pvalue > 0.05:
return 0
if 0.01 < pvalue < 0.05:
return 1
if 0.001 < pvalue < 0.01:
return 2
if pvalue < 0.001:
return 3
#"""
return pvalue
###################################################
###################################################
for gt_image, seg_image in zip(gt_image_list, seg_image_list):
print(gt_image)
gt = cv2.imread(gt_folder_path + "/" + gt_image, cv2.IMREAD_GRAYSCALE)
seg = cv2.imread(seg_folder_path + "/" + seg_image, cv2.IMREAD_GRAYSCALE)
# label image mask
gt_labelled = label(gt)
seg_labelled = label(seg)
# Get region props of labelled images
gt_reg_props = regionprops(gt_labelled)
seg_reg_props = regionprops(seg_labelled)
# compare shape descriptor distributions
#################################
# Area
gt_area = [i.area for i in gt_reg_props]
seg_area = [i.area for i in seg_reg_props]
pvalue_area = mannwhitneyu(gt_area, seg_area)[1]
list_area.append(significance(pvalue_area))
#list_area.append(pvalue_area)
list_area2.append(cohens_d(gt_area, seg_area))
# Eccentricity
gt_ecc = [i.eccentricity for i in gt_reg_props]
seg_ecc = [i.eccentricity for i in seg_reg_props]
pvalue_ecc = mannwhitneyu(gt_ecc, seg_ecc)[1]
list_ecc.append(significance(pvalue_ecc))
#list_ecc.append(pvalue_ecc)
list_ecc2.append(cohens_d(gt_ecc, seg_ecc))
# Aspect ratio
gt_ar = [i.major_axis_length/i.minor_axis_length for i in gt_reg_props if i.minor_axis_length != 0]
seg_ar = [i.major_axis_length/i.minor_axis_length for i in seg_reg_props if i.minor_axis_length != 0]
pvalue_ar = mannwhitneyu(gt_ar, seg_ar)[1]
list_ar.append(significance(pvalue_ar))
#list_ar.append(pvalue_ar)
list_ar2.append(cohens_d(gt_ar, seg_ar))
# Perimeter
gt_per = [i.perimeter for i in gt_reg_props]
seg_per = [i.perimeter for i in seg_reg_props]
pvalue_per = mannwhitneyu(gt_per, seg_per)[1]
list_per.append(significance(pvalue_per))
#list_per.append(pvalue_per)
list_per2.append(cohens_d(gt_per, seg_per))
# Solidity
gt_sol = [i.solidity for i in gt_reg_props]
seg_sol = [i.solidity for i in seg_reg_props]
#print(len(gt_sol))
pvalue_sol = mannwhitneyu(gt_sol, seg_sol)[1]
list_sol.append(significance(pvalue_sol))
#list_sol.append(pvalue_sol)
list_sol2.append(cohens_d(gt_sol, seg_sol))
#################################
def show(gt, seg):
sb.kdeplot(gt, color="green", shade=True)
sb.kdeplot(seg, color="red", shade=True)
plt.show()
def norm(gt, seg):
print(normaltest(gt)[1])
print(normaltest(seg)[1])
#norm(gt_area, seg_area)
#norm(gt_ecc, seg_ecc)
#norm(gt_ar, seg_ar)
#norm(gt_per, seg_per)
#norm(gt_sol, seg_sol)
"""
#show(gt_area, seg_area)
#print(pvalue_area)
print(energy_distance(gt_area, seg_area))
#show(gt_ecc, seg_ecc)
#print(pvalue_ecc)
print(energy_distance(gt_ecc, seg_ecc))
#show(gt_ar, seg_ar)
#print(pvalue_ar)
print(energy_distance(gt_ar, seg_ar))
#show(gt_per, seg_per)
#print(pvalue_per)
print(energy_distance(gt_per, seg_per))
#show(gt_sol, seg_sol)
#print(pvalue_sol)
print(energy_distance(gt_sol, seg_sol))
"""
df["Image"] = gt_image_list
df["Area"] = list_area
df["Eccentricity"] = list_ecc
df["Aspect Ratio"] = list_ar
df["Perimeter"] = list_per
df["Solidity"] = list_sol
df_2["Image"] = gt_image_list
df_2["Area"] = list_area2
df_2["Eccentricity"] = list_ecc2
df_2["Aspect Ratio"] = list_ar2
df_2["Perimeter"] = list_per2
df_2["Solidity"] = list_sol2
total_values = len(gt_image_list)*5
zero_p = 0
one_p = 0
two_p = 0
three_p = 0
for index, row in df.iterrows():
for column in row:
if column == 0:
zero_p+=1
elif column == 1:
one_p+=1
elif column == 2:
two_p+=1
elif column == 3:
three_p+=1
#print(zero_p/total_values)
#print(one_p/total_values)
#print(two_p/total_values)
#print(three_p/total_values)
# raw data
df.to_csv(path + seg_name + "_Morph_Dist_comparison.csv")
