def test_single_point(self):
img = np.ones((11, 11))
img[6, 6] = 0
dgm = lower_star_img(img)
assert dgm.shape[0] == 1
assert tuple(dgm[0]) == (0, np.inf)
def getSegmentation(F):
'''
This function computes the step in the filtration of binary images that we will use later onto find a suitable mask.
:type F: numpy.array
:param F: 3D array representing the filtration of binary images. The dimensions correspond to height x width x step_in_filtration.
:retrun: numpy.array - Binary image that will be used to compute the mask.3
'''
if F.ndim != 3:
print('ERROR: The parameter F must be a 3D-array.')
return
prev_num_connected_componnets = img.shape[0]*img.shape[1]
T2 = 0
for i in range(F.shape[2]):
# Compute 0-dim persistence
dgm = lower_star_img(F[:,:,i])
# We need to clear out results since nany point with persistence (-0,infy) is point that never was part of the diagram.
# ind_of_zeros = np.where(dgm[:,0] == 0)[0]
# dgm = np.delete(dgm, ind_of_zeros, axis=0)
# The stopping condition comes whenever S_{t+1} has more connected components than S_t
if dgm.shape[0] <= prev_num_connected_componnets:
prev_num_connected_componnets = dgm.shape[0]
else:
T2 = i-1
break
T1 = int(1 + np.floor(T2/4))
selected = F[:,:,T1]
return selected
# plt.savefig('mask.png')
# Apply mask to image
masked_img = cv2.bitwise_and(img, img, mask=mask)
# fig, ax = plt.subplots(1,1, figsize=(10,10))
# ax.imshow(masked_img, cmap='gray')
# plt.savefig('masked_img.png')
# RGB
dgm_R_rgb.append(lower_star_img(-masked_img[:, :, 0]))
dgm_G_rgb.append(lower_star_img(-masked_img[:, :, 1]))
dgm_B_rgb.append(lower_star_img(-masked_img[:, :, 2]))
# HSV
masked_img_hsv = skimage.color.rgb2hsv(masked_img)
dgm_H_hsv.append(lower_star_img(-masked_img_hsv[:, :, 0]))
dgm_S_hsv.append(lower_star_img(-masked_img_hsv[:, :, 1]))
dgm_V_hsv.append(lower_star_img(-masked_img_hsv[:, :, 2]))
# XYZ
masked_img_xyz = skimage.color.rgb2xyz(masked_img)
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy import ndimage
import PIL
from ripser import ripser, plot_dgms, lower_star_img
ts = np.linspace(-1, 1, 100)
x1 = np.exp(-ts**2/(0.1**2))
ts -= 0.4
x2 = np.exp(-ts**2/(0.1**2))
img = -x1[None, :]*x1[:, None] - 2*x1[None, :]*x2[:, None] - 3*x2[None, :]*x2[:, None]
dgm = lower_star_img(img)
plt.figure(figsize=(10, 5))
plt.subplot(121)
plt.imshow(img)
plt.colorbar()
plt.title("Test Image")
plt.subplot(122)
plot_dgms(dgm)
plt.title("0-D Persistence Diagram")
plt.tight_layout()
plt.show()
def RipserMat(i,j):
index=[]
if j!=99:
j=s.index(i)
else:
j=99
mat=np.array(i) #prodce single matrix per letter
mat=mat.astype(np.float) #convert to float
co = np.argwhere(mat!=0)# create matrix of coordinates
if len(co)==0: #if empty data set then all values are 0
H1=0;H2=0;H3=0;R1=(0,0);R2=(0,0);RL0=0;RRL0=(0,0);RRL1=(0,0);RRL2=(0,0);LR0=0;RLR0=(0,0);RLR1=(0,0);RLR2=(0,0);TB0=0;RTB0=(0,0);RTB1=(0,0);RTB2=(0,0);
BT0=0;RBT0=(0,0);RBT1=(0,0);RBT2=(0,0);LL0=0;LL1= 0;LL2=0;LLLS0=0;LLLS1=0;LLLS2=0;CO0=0;CO1= 0;CO2=0;COLS0=0;COLS1=0;COLS2=0;CI0=0;
CI1= 0;CI2=0;CILS0=0;CILS1=0;CILS2=0;RLLS0= 0;RLLS1=0;RLLS2=0;LRLS0=0;LRLS1=0;LRLS2=0;TBLS0=0;TBLS1=0;TBLS2=0;BTLS0=0;BTLS1=0;BTLS2=0
ranges= [RLLS0,RLLS1,RLLS2,LRLS0,LRLS1,LRLS2,TBLS0,TBLS1,TBLS2,BTLS0,BTLS1,BTLS2,LLLS0,LLLS1,LLLS2,COLS0,COLS1,COLS2,CILS0,CILS1,CILS2,H1,H2,H3]
else:
dgms = ripser(co)['dgms']#analyses the point cloud of coordinates in ripser
OneDset=(dgms[1:][0])#defines the range of 1D homology ""
if len(OneDset)>0: #delete all repeated values
OneDset=np.unique(OneDset, axis=0)
H1=len(OneDset)
for h in np.arange(len(OneDset)):
index1=(OneDset[h][1])
index0=(OneDset[h][0])
feat=np.subtract((OneDset[h][1]),(OneDset[h][0]))
#removes noise in 1D
if feat < 1:
index.append(h)
OneDset= np.delete(OneDset,index,0)
H1=(len(OneDset))
H2=0
H3=0
if H1 ==1:
H1=0
H2=100
H3=0
elif H1 ==0 :
H1=100
elif H1 ==2:
H1=0
H2=0
H3=100
#RIGHT TO LEFT scan
RLmat=RightToLeft(mat)
dgm = lower_star_img(RLmat)
RL0=len(dgm)
RLLS0,RLLS1,RLLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
LRmat=LeftToRight(mat)
dgm = lower_star_img(LRmat)
LR0=len(dgm)
LRLS0,LRLS1,LRLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
TBmat=TopToBottom(mat)
dgm = lower_star_img(TBmat)
TB0=len(dgm)
TBLS0,TBLS1,TBLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
BTmat=BottomToTop(mat)
dgm = lower_star_img(BTmat)
BT0=len(dgm)
BTLS0,BTLS1,BTLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
LLmat= Diag_Array_LL(mat)
dgm = lower_star_img(LLmat)
LL0=len(dgm)
LLLS0,LLLS1,LLLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
COmat=CenterOutFiltration(mat)
dgm = lower_star_img(COmat)
CO0=len(dgm)
COLS0,COLS1,COLS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
CImat=CenterInFiltration(mat)
dgm = lower_star_img(CImat)
CI0=len(dgm)
CILS0,CILS1,CILS2= USDictionaryUpdate(dgm)
mat=np.array(i)
mat=mat.astype(np.float)
ranges= [RLLS0,RLLS1,RLLS2,LRLS0,LRLS1,LRLS2,TBLS0,TBLS1,TBLS2,BTLS0,BTLS1,BTLS2,LLLS0,LLLS1,LLLS2,COLS0,COLS1,COLS2,CILS0,CILS1,CILS2,H1,H2,H3]
for i in range(len(ranges)):
if i<=2 and ranges[i]!=0.0:
ClassificationKey.append([j,1,ranges[i]])
elif 2<i<=5 and ranges[i]!=0.0:
ClassificationKey.append([j,2,ranges[i]])
elif 5<i<=8 and ranges[i]!=0.0:
ClassificationKey.append([j,3,ranges[i]])
elif 8<i<=11 and ranges[i]!=0.0:
ClassificationKey.append([j,4,ranges[i]])
elif 11<i<=14 and ranges[i]!=0.0:
ClassificationKey.append([j,5,ranges[i]])
elif 14<i<=17 and ranges[i]!=0.0:
ClassificationKey.append([j,6,ranges[i]])
elif 17<i<=20 and ranges[i]!=0.0:
ClassificationKey.append([j,7,ranges[i]])
return ranges,ClassificationKey
pim = PersImage(spread=pim_sd, pixels=[pim_px,pim_px], verbose=False)
# generate SSMs for each gesture
raw_ssm_lst = [np.zeros(shape=(a.shape[0], a.shape[0])) for a in arrays]
for n, a in enumerate(arrays):
for i in range(a.shape[0]):
for j in range(a.shape[0]):
raw_ssm_lst[n][i,j] = cumulated_ts_2(a[i,:],a[j,:])
# smooth SSM images
for r, s in enumerate(raw_ssm_lst):
raw_ssm_lst[r] = gaussian_filter(s, sigma=1)
# generate persistence images
for n, s in enumerate(raw_ssm_lst):
pd = lower_star_img(s)
img = pim.transform(pd[:-1,:]) # remove 'inf' persistence
raw_pim_mat[n,:-2] = img.reshape(1,-1)
raw_pim_mat[n,-2] = subj_lab[n]
raw_pim_mat[n,-1] = gest_lab[n]
# save matrix as DataFrame
raw_pim_df = DataFrame(raw_pim_mat)
cnames = ["px"+str(i) for i in raw_pim_df.columns]
cnames[-2:] = ["subj", "gest"]
raw_pim_df.columns = cnames
raw_pim_df.to_csv("./Data/raw_pim_vectors.csv", index=False)
############################################################################
################################ ISOMAP SSMs ###############################
############################################################################
def test_returns_dgm(self):
img = np.random.random((100, 400))
dgm = lower_star_img(img)
assert isinstance(dgm, np.ndarray)
assert dgm.shape[1] == 2
assert np.all(dgm[:, 1] >= dgm[:, 0])
def topological_process_img(img, dgm=None, tau=None, window_size=None, border_width=None):
return_modified = False
if dgm is None:
if window_size is not None:
img = smoothen(img, window_size=window_size)
return_modified = True
if border_width is not None:
img = add_border(img, border_width=border_width)
return_modified = True
dgm = lower_star_img(img)
if tau is None:
dgm_lifetimes, tau = lifetimes_from_dgm(dgm, tau=True)
else:
dgm_lifetimes = lifetimes_from_dgm(dgm)
idxs = np.where(np.logical_and(tau < dgm_lifetimes[:,1], dgm_lifetimes[:,1] < np.inf))[0]
idxs = np.flip(idxs[np.argsort(dgm[idxs, 0])])
didxs = np.zeros(0).astype("int")
img_components = np.zeros_like(img)
dist = np.zeros([len(idxs), img.shape[0], img.shape[1]])
nearest_value = np.zeros([len(idxs), img.shape[0], img.shape[1]])
for i, idx in enumerate(idxs):
bidx = np.argmin(np.abs(img - dgm[idx, 0]))
didxs = np.append(didxs, np.argmin(np.abs(img - dgm[idx, 1])))
img_temp = np.ones_like(img)
img_temp[np.logical_or(img < dgm[idx, 0] - 0.01, dgm[idx, 1] - 0.01 < img)] = np.nan
component_at_idx = connected_components_img(img_temp)
del(img_temp)
component_at_idx = component_at_idx == component_at_idx[bidx // img.shape[1], bidx % img.shape[1]]
if i > 0:
didxs_in_component = idxs[np.where([component_at_idx[didx // img.shape[1], didx % img.shape[1]]
for didx in didxs])[0]]
if len(didxs_in_component) > 0:
component_at_idx[img > np.min(dgm[didxs_in_component, 1]) - 0.1] = False
img_components[component_at_idx] = 1
img_temp = np.ones_like(img)
img_temp[component_at_idx] = 0
dist[i,:,:], nearest_neighbor_temp = distance_transform_edt(img_temp, return_indices=True)
nearest_value[i,:,:] = img[nearest_neighbor_temp[0], nearest_neighbor_temp[1]]
del(img_temp, nearest_neighbor_temp)
img_processed = np.zeros_like(img)
all_components = img_components > 0
img_processed[all_components] = img[all_components]
with np.errstate(divide="ignore"):
img_processed[~all_components] = np.sum(nearest_value / dist, axis=0)[~all_components] / \
np.sum(1 / dist, axis=0)[~all_components]
if return_modified:
return {"modified": img, "components": img_components, "processed": img_processed}
return {"components": img_components, "processed": img_processed}
