def compute_Betti_bumbers(img, th=0.5): z, y, x = img.shape img_v = img.flatten() cc = gd.CubicalComplex(dimensions=(z, y, x), top_dimensional_cells=1 - img_v) cc.persistence(min_persistence=th) return cc.persistent_betti_numbers(0, th)
def compute_dgm(f, card, hom_dim): """ Computes the persistence diagram of an image. :param f: image :param card: maximum number of bars kept :param hom_dim: dimension of homology :return: persistence diagram, critical pixels """ dgm = np.zeros([card, 2], dtype=np.float32) cof = np.zeros([card, 2], dtype=np.int32) cc = gd.CubicalComplex(dimensions=f.shape, top_dimensional_cells=f.ravel()) cc.compute_persistence() # Return zero arrays if no finite bars num_bars = len(cc.persistence_intervals_in_dimension(hom_dim)) if ((hom_dim == 0) and (num_bars == 1)) or ((hom_dim > 0) and (num_bars == 0)): return dgm, cof # These are all the critical pixels all_cof = cc.cofaces_of_persistence_pairs()[0][hom_dim] # Generate the persistence diagram birth_times, death_times = f.flat[all_cof[:, 0]], f.flat[all_cof[:, 1]] # Return at most param:card bars min_card = min(len(birth_times), card) dgm[:min_card, 0], dgm[:min_card, 1] = birth_times[:min_card], death_times[:min_card] cof[:min_card, :] = all_cof[:min_card, :] return dgm, cof
def compute_thresh_dgm(f, card, hom_dim, pers_region=None): """ Computes thresholded persistent homology of an image. :param f: input image :param card: max cardinality of persistence diagram :param hom_dim: degree of homology :param pers_region: np.array([birth_low, birth_high, lifetime_low, lifetime_high]) :return: persistence diagram and associated critical pixels """ dgm = np.zeros([card, 2], dtype=np.float32) cof = np.zeros([card, 2], dtype=np.int32) cc = gd.CubicalComplex(dimensions=f.shape, top_dimensional_cells=f.ravel()) cc.compute_persistence() # Return zero arrays if no finite bars num_bars = len(cc.persistence_intervals_in_dimension(hom_dim)) if ((hom_dim == 0) and (num_bars == 1)) or ((hom_dim > 0) and (num_bars == 0)): return dgm, cof # These are all the critical pixels all_cof = cc.cofaces_of_persistence_pairs()[0][hom_dim] # Generate the persistence diagram birth_times, death_times = f.flat[all_cof[:, 0]], f.flat[all_cof[:, 1]] # Threshold by persistence region if one was provided if pers_region is not None: lifetimes = death_times - birth_times rel_ind = (pers_region[0] < birth_times) & (birth_times < pers_region[1]) & \ (pers_region[2] < lifetimes) & (lifetimes < pers_region[3]) birth_times, death_times, all_cof = birth_times[rel_ind], death_times[ rel_ind], all_cof[rel_ind, :] min_card = min(len(birth_times), card) dgm[:min_card, 0], dgm[:min_card, 1] = birth_times[:min_card], death_times[:min_card] cof[:min_card, :] = all_cof[:min_card, :] return dgm, cof
def barcode(filt): cplx = gudhi.CubicalComplex(dimensions=filt.shape, top_dimensional_cells=filt.flatten(order="F")) pd = cplx.persistence(homology_coeff_field=2, min_persistence=0) return pd
def getCriticalPoints(likelihood): lh = 1 - likelihood lh_vector = np.asarray(lh).flatten() lh_cubic = gd.CubicalComplex(dimensions=[lh.shape[0], lh.shape[1]], top_dimensional_cells=lh_vector) Diag_lh = lh_cubic.persistence(homology_coeff_field=2, min_persistence=0) pairs_lh = lh_cubic.cofaces_of_persistence_pairs() # if(torch.min(lh_patch) == 1 or torch.max(lh_patch) == 0): continue # if(torch.min(gt_patch) == 1 or torch.max(gt_patch) == 0): continue # return persistence diagram, birth/death critical points pd_lh = numpy.array( [[lh_vector[pairs_lh[0][0][i][0]], lh_vector[pairs_lh[0][0][i][1]]] for i in range(len(pairs_lh[0][0]))]) bcp_lh = numpy.array([[ pairs_lh[0][0][i][0] // lh.shape[1], pairs_lh[0][0][i][0] % lh.shape[1] ] for i in range(len(pairs_lh[0][0]))]) dcp_lh = numpy.array([[ pairs_lh[0][0][i][1] // lh.shape[1], pairs_lh[0][0][i][1] % lh.shape[1] ] for i in range(len(pairs_lh[0][0]))]) return pd_lh, bcp_lh, dcp_lh
def Cubical(X, dim, card): # Parameters: X (image), # dim (homological dimension), # card (number of persistence diagram points, sorted by distance-to-diagonal) # Compute the persistence pairs with Gudhi cc = gd.CubicalComplex(dimensions=X.shape, top_dimensional_cells=X.flatten()) cc.persistence() try: cof = cc.cofaces_of_persistence_pairs()[0][dim] except IndexError: cof = np.array([]) Xs = X.shape if len(cof) > 0: # Sort points with distance-to-diagonal pers = [ X[np.unravel_index(cof[idx, 1], Xs)] - X[np.unravel_index(cof[idx, 0], Xs)] for idx in range(len(cof)) ] perm = np.argsort(pers) cof = cof[perm[::-1]] # Retrieve and ouput image indices/pixels corresponding to positive and negative simplices D = len(Xs) ocof = np.array([0 for _ in range(D * card * 2)]) count = 0 for idx in range(0, min(2 * card, 2 * cof.shape[0]), 2): ocof[D * idx:D * (idx + 1)] = np.unravel_index(cof[count, 0], Xs) ocof[D * (idx + 1):D * (idx + 2)] = np.unravel_index(cof[count, 1], Xs) count += 1 return list(np.array(ocof, dtype=np.int32))
def get_persistence_image(img, thresh=128, C=0.5, p=1, size=51, sigma=0.5, win={ 'xmin': -10.5, 'xmax': 60.5, 'ymin': -10.5, 'ymax': 70.5 }): arr = np.array(img) for i in range(arr.shape[0]): for j in range(arr.shape[1]): if arr[i, j] > thresh: arr[i, j] = 1 else: arr[i, j] = 0 fil = manhattan(arr) cp = gudhi.CubicalComplex(dimensions=fil.shape, top_dimensional_cells=[ fil[i, j] for i in range(fil.shape[0] - 1, -1, -1) for j in range(fil.shape[1]) ]) pers = cp.persistence() h0 = [p[1] for p in pers if p[0] == 0] h1 = [p[1] for p in pers if p[0] == 1] def rho(x, y, points): somme = 0 for p in points: we = 1 if p[1] == math.inf: we = 1. a = np.exp(-((p[0] - x)**2 + (win["ymax"] - y)**2) / (2 * sigma**2)) else: we = w(p[0], p[1]) a = np.exp(-((p[0] - x)**2 + (p[1] - y)**2) / (2 * sigma**2)) somme += we * a return somme xx = np.linspace(win['xmin'], win['xmax'], size) yy = np.linspace(win['ymax'], win['ymin'], size) image0 = np.zeros((size, size)) image1 = np.zeros((size, size)) for j, x in enumerate(xx): for i, y in enumerate(yy): if (y >= x): image0[i, j] = rho(x, y, h0) image1[i, j] = rho(x, y, h1) return image0, image1
def _cubical_complex(self, points): shape = [points.shape[0]] * 2 bitmap = np.zeros(shape) # You can do other calculations for the bitmap values, # this is just an example I found. for i, p1 in enumerate(points): for j, p2 in enumerate(points): norm = np.linalg.norm(p1 - p2) bitmap[i, j] = norm cube = gd.CubicalComplex(top_dimensional_cells=bitmap.flatten(), dimensions=shape) diag = cube.persistence() return diag
def PH_diag(img, patch_side): cc = gd.CubicalComplex(dimensions=(patch_side, patch_side, patch_side), top_dimensional_cells=1 - img.flatten()) diag = cc.persistence() plt.figure(figsize=(3, 3)) # diag_clean = diag_tidy(diag, 1e-3) gd.plot_persistence_barcode(diag, max_intervals=0, inf_delta=100) print(diag) plt.xlim(0, 1) plt.ylim(-1, len(diag)) plt.xticks(ticks=np.linspace(0, 1, 6), labels=np.round(np.linspace(1, 0, 6), 2)) plt.yticks([]) plt.show()
def image_persistence(flare_obj, threshold, SHARP, timeline, intensity, frametime, ftype, hour, PIL=True): mask = np.array(flare_obj["PIL_MASK"]) index = timeline.index(frametime[6:]) flare_intensity = intensity[index] p_feature = [flare_intensity] for ch in SHARP: image = np.array(flare_obj[ch]) # preprocess the image for cubical complex construction if PIL == True: check = np.logical_or(np.isnan(image), mask == 0) else: check = np.isnan(image) image[check] = np.inf if (ch in ['Br', 'TOTUSJZ', 'TOTUSJH']): image = np.abs(image) fname = "./Penseus/" + ch + "_" + ftype + str(hour) + ".txt" perseus_gen(image, fname=fname) cubical_complex = gudhi.CubicalComplex(perseus_file=fname) cubical_complex.compute_persistence() cubical_complex.persistence() q = threshold[ch] for q_value in q.values: q_value = float(q_value) p_feature.append( cubical_complex.persistent_betti_numbers( from_value=q_value, to_value=q_value)[1]) # number # of live holes for SHARP_feature in [ 'USFLUX', 'MEANGAM', 'MEANGBT', 'MEANGBH', 'MEANGBZ', 'MEANJZD', 'TOTUSJZ', 'MEANALP', 'TOTUSJH', 'SAVNCPP', 'MEANPOT', 'MEANSHR' ]: p_feature.append(flare_obj.attrs[SHARP_feature]) return np.array(p_feature)
def save_PH_diag(img, patch_side, outdir): cc = gd.CubicalComplex(dimensions=(patch_side, patch_side, patch_side), top_dimensional_cells=1 - img.flatten()) diag = cc.persistence() plt.figure(figsize=(3, 3)) diag_clean = diag_tidy(diag, 1e-3) print(diag_clean) # np.savetxt(os.path.join(outdir, 'generalization.csv'), diag_clean, delimiter=",") with open(os.path.join(outdir, 'generalization.txt'), 'wt') as f: for ele in diag_clean: f.write(ele + '\n') gd.plot_persistence_barcode(diag_clean) plt.ylim(-1, len(diag_clean)) plt.xticks(ticks=np.linspace(0, 1, 6), labels=np.round(np.linspace(1, 0, 6), 2)) plt.yticks([]) plt.savefig(os.path.join(outdir, "PH_diag.png"))
def PH_diag(img): z, y, x = img.shape cc = gd.CubicalComplex(dimensions=(z, y, x), top_dimensional_cells=1 - img.flatten()) diag = cc.persistence() plt.figure(figsize=(3, 3)) gd.plot_persistence_barcode(diag, max_intervals=0, inf_delta=100) plt.xlim(0, 1) plt.ylim(-1, len(diag)) plt.xticks(ticks=np.linspace(0, 1, 6), labels=np.round(np.linspace(1, 0, 6), 2)) plt.yticks([]) plt.show() gd.plot_persistence_diagram(diag, legend=True) plt.show() gd.plot_persistence_density(diag, legend=True) plt.show()
def calculate_diagram_gudhi(image): reshaped = np.reshape(image, [image.shape[0] * image.shape[1]], order='F') # reshapes image to a single vector Complex = gudhi.CubicalComplex(dimensions=image.shape, top_dimensional_cells=reshaped) # creates the cubical complex from the image Complex.persistence() Dgm0 = Complex.persistence_intervals_in_dimension(0) # compute oth dimensional persistence diagram Dgm1 = Complex.persistence_intervals_in_dimension(1) return Dgm0, Dgm1
def cube_hom(name, array): cubical = gd.CubicalComplex(dimensions=array.shape, top_dimensional_cells=array.flatten()) #Calculate the persistent homology of the filtered cubical complex phom = cubical.persistence() #Persistence homology per dimension phom_0 = cubical.persistence_intervals_in_dimension(0) phom_1 = cubical.persistence_intervals_in_dimension(1) phom_2 = cubical.persistence_intervals_in_dimension(2) #Creating a third column listing dim number if len(phom_0) != 0: phom_0_form = (np.append(phom_0, np.zeros([len(phom_0), 1]), 1) + np.array([0, 0, 0])) else: phom_0_form = phom_0 if len(phom_1) != 0: phom_1_form = (np.append(phom_1, np.zeros([len(phom_1), 1]), 1) + np.array([0, 0, 1])) else: phom_1_form = phom_1 if len(phom_2) != 0: phom_2_form = (np.append(phom_2, np.zeros([len(phom_2), 1]), 1) + np.array([0, 0, 2])) else: phom_2_form = phom_2 file_name = str(path) + '/Python_Hom/' + name + ".csv" # opening the csv file in 'w+' mode file = open(file_name, 'w+', newline='') # writing the data into the file with file: write = csv.writer(file) write.writerows(phom_0_form) write.writerows(phom_1_form) write.writerows(phom_2_form)
def getCriticalPoints(likelihood): """ Compute the critical points of the image (Value range from 0 -> 1) Args: likelihood: Likelihood image from the output of the neural networks Returns: pd_lh: persistence diagram. bcp_lh: Birth critical points. dcp_lh: Death critical points. Bool: Skip the process if number of matching pairs is zero. """ lh = 1 - likelihood lh_vector = np.asarray(lh).flatten() lh_cubic = gd.CubicalComplex(dimensions=[lh.shape[0], lh.shape[1]], top_dimensional_cells=lh_vector) Diag_lh = lh_cubic.persistence(homology_coeff_field=2, min_persistence=0) pairs_lh = lh_cubic.cofaces_of_persistence_pairs() # If the paris is 0, return False to skip if (len(pairs_lh[0]) == 0): return 0, 0, 0, False # return persistence diagram, birth/death critical points pd_lh = numpy.array( [[lh_vector[pairs_lh[0][0][i][0]], lh_vector[pairs_lh[0][0][i][1]]] for i in range(len(pairs_lh[0][0]))]) bcp_lh = numpy.array([[ pairs_lh[0][0][i][0] // lh.shape[1], pairs_lh[0][0][i][0] % lh.shape[1] ] for i in range(len(pairs_lh[0][0]))]) dcp_lh = numpy.array([[ pairs_lh[0][0][i][1] // lh.shape[1], pairs_lh[0][0][i][1] % lh.shape[1] ] for i in range(len(pairs_lh[0][0]))]) return pd_lh, bcp_lh, dcp_lh, True
def compute_persistence_diagram(matrix, min_pers=0, i=5): """ Given a matrix representing a nii image compute the persistence diagram by using the Gudhi library (link) :param matrix: matrix encoding the nii image :type matrix: np.array :param min_pers: minimum persistence interval to be included in the persistence diagram :type min_pers: Integer :returns: Persistence diagram encoded as a list of tuples [d,x,y]=p where * d: indicates the dimension of the d-cycle p * x: indicates the birth of p * y: indicates the death of p """ #save the dimenions of the matrix dims = matrix.shape size = reduce(lambda x, y: x * y, dims, 1) #create the cubica complex from the image cubical_complex = gudhi.CubicalComplex(dimensions=dims, top_dimensional_cells=np.reshape( matrix.T, size)) #compute the persistence diagram if i == 5: pd = cubical_complex.persistence(homology_coeff_field=2, min_persistence=min_pers) return np.array(map(lambda row: [row[1][0], row[1][1]], pd)) else: pd = cubical_complex.persistence(homology_coeff_field=2, min_persistence=min_pers) pd = cubical_complex.persistence_intervals_in_dimension(i) return np.array(list(map(lambda row: [row[0], row[1]], pd)))
def fractional_lifespancurve(image, height, width, pixel): """ Returns a window (needs height h, weight w) based on input dimensions and pixel location Args -------- image: numpy array image to be sliced casted as numpy array height: int desired height for the window image width: int desired width for the window image pixel: numpy array coordinates of where the window will be created Returns -------- padded_window: numpy array the window sliced from the original image; pads the image with 0's if indexing goes beyond the image dimensions """ # convert image if not numpy array if type(image) is not np.array: image = np.array(image) h = height w = width n, m = image.shape x, y = pixel window = np.zeros([h, w]) for i in range(x, x + h): for j in range(y, y + w): if i >= n - 1 and j >= m - 1: window[i - x, j - y] = 0 else: window[i - x, j - y] = image[i, j] #padding out of bounds entry with 0s fraction_image = window reshaped = np.reshape(fraction_image, [fraction_image.shape[0] * fraction_image.shape[1]], order='F') # reshapes image to a single vector Complex = gudhi.CubicalComplex(dimensions=fraction_image.shape, top_dimensional_cells=reshaped) # creates the cubical complex from the image Complex.persistence() Dgm0 = Complex.persistence_intervals_in_dimension(0) # compute oth dimensional persistence diagram Dgm1 = Complex.persistence_intervals_in_dimension(1) # computes 1st dimensional persistenence diagram return Dgm0, fraction_image
from IPython.display import Image from sklearn.neighbors.kde import KernelDensity f = open("crater_tuto") #For python 3 #crater = pickle.load(f,encoding='latin1') #For python 2 crater = pickle.load(f) f.close() plt.scatter(crater[:, 0], crater[:, 1], s=0.1) plt.show() #create 10 by 10 cubical complex: xval = np.arange(0, 10, 0.05) yval = np.arange(0, 10, 0.05) nx = len(xval) ny = len(yval) #Now we compute the values of the kernel density estimator on the center of each point of our grid. #The values will be stored in the array scores. kde = KernelDensity(kernel='gaussian', bandwidth=0.3).fit(crater) positions = np.array([[u, v] for u in xval for v in yval]) scores = -np.exp(kde.score_samples(X=positions)) #And subsequently construct a cubical complex based on the scores. cc_density_crater = gd.CubicalComplex(dimensions=[nx, ny], top_dimensional_cells=scores) # OPTIONAL pers_density_crater = cc_density_crater.persistence() plt = gd.plot_persistence_diagram(pers_density_crater).show()
# print(j) for i in range(0, numwinB): # print (i) # print(windowsA[i,::10]) V_x = -1.0 * windowsB[i, ::10] / 2 V_y = (-1.0 / np.sqrt(2)) * windowsB[i, ::10] / 2 V_z = -0.5 * windowsB[i, ::10] / 2 V_w = (-1.0 / np.sqrt(5)) * windowsB[i, ::10] / 2 fieldB[:, i] = 0.5 * (-1.0 * np.kron(np.kron(V_x, V_y), V_z) - 1.0 * np.kron(np.kron(V_y, V_z), V_w)) print(np.shape(fieldB)) L_a = np.empty([numwinA, 5000]) for i in range(0, numwinA): cubical_complex = gd.CubicalComplex( dimensions=[30, 30, 30], top_dimensional_cells=fieldA[:, i], ) diag = cubical_complex.persistence(homology_coeff_field=2, min_persistence=10) #gd.plot_persistence_diagram(diag) #print(cubical_complex.betti_numbers()) LS = gd.representations.Landscape(resolution=1000) L_a[i, :] = LS.fit_transform( [cubical_complex.persistence_intervals_in_dimension(2)]) print(np.shape(L_a)) L_hatA = np.mean(L_a, axis=0) L_b = np.empty([numwinB, 5000]) for i in range(0, numwinB): cubical_complex = gd.CubicalComplex(
epilog="Example: " "./random_cubical_complex_persistence_example.py" " 10 10 10 - Constructs a random cubical " "complex in a dimension [10, 10, 10] (aka. " "1000 random top dimensional cells).", ) parser.add_argument("dimension", type=int, nargs="*", help="Cubical complex dimensions") args = parser.parse_args() dimension_multiplication = reduce(operator.mul, args.dimension, 1) if dimension_multiplication > 1: print( "#####################################################################" ) print("CubicalComplex creation") cubical_complex = gudhi.CubicalComplex( dimensions=args.dimension, top_dimensional_cells=numpy.random.rand(dimension_multiplication), ) print("persistence(homology_coeff_field=2, min_persistence=0)=") print( cubical_complex.persistence(homology_coeff_field=2, min_persistence=0)) print("betti_numbers()=") print(cubical_complex.betti_numbers())
import matplotlib.pyplot as plt import numpy as np import random as rd from mpl_toolkits.mplot3d import Axes3D import csv from sklearn import decomposition import math import gudhi as gd from PIL import Image #in this example we are considering two dimensional complexes N = 100 #this is where you set the probability: p = 0.6 bitmap = [] for i in range(0,N*N): x = rd.uniform(0, 1) if ( x < p ): bitmap.append(1) else: bitmap.append(0) bcc = gd.CubicalComplex(top_dimensional_cells = bitmap, dimensions=[N,N]) diag = bcc.persistence() #now we can check how many generators in dimension 0 and in dimension 1 we have: dim0 = bcc.persistence_intervals_in_dimension(0) dim1 = bcc.persistence_intervals_in_dimension(1) print "Here is the first Betti number: ", len(dim0) print "Here is the second Betti number: ", len(dim1)
img_arr = np.squeeze(np.stack(images,axis=-1)) if args.distance_transform: img_arr = dt(img_arr) print("input shape: ",img_arr.shape) start = time.time() if args.software=="gudhi": try: import gudhi except: print("Install pydicom first by: conda install -c conda-forge gudhi") exit() print("Computing PH with GUDHI (T-construction)") gd = gudhi.CubicalComplex(top_dimensional_cells=img_arr) # gd.compute_persistence() res = np.array(gd.persistence(2,0)) # coeff = 2 print("Betti numbers: ", gd.persistent_betti_numbers(np.inf,-np.inf)) else: if args.filtration=='V': res = cripser.computePH(img_arr,maxdim=args.maxdim,top_dim=args.top_dim,embedded=args.embedded) else: res = tcripser.computePH(img_arr,maxdim=args.maxdim,top_dim=args.top_dim,embedded=args.embedded) print("Betti numbers: ", [res[res[:,0]==i].shape[0] for i in range(3)]) # print(res[:10]) print ("computation took:{} [sec]".format(time.time() - start)) if args.output is not None:
def Persistence_windows(image, height, width , pixel): """ Returns a window (needs height h, weight w) based on input dimensions and pixel location Args -------- image: numpy array image to be sliced casted as numpy array height: int desired height for the window image width: int desired width for the window image pixel: numpy array coordinates of where the window will be created Returns -------- padded_window: numpy array the window sliced from the original image; pads the image with 0's if indexing goes beyond the image dimensions """ # convert image if not numpy array if type(image) is not np.array: image = np.array(image) h = height w = width n, m = image.shape x,y = pixel window = np.zeros([h,w]) diskwindow = np.zeros([h,w]) for i in range(x, x+h): for j in range(y, y+w): if i >= n-1 or j >= m-1: #we discuss this earlier but afterwards #I realize the "and" statement is justified #since we start with an array of 0 and later #add values. Hence the "or" case would be zeroed out #regardless. window[i-x,j-y]= float('inf') else: window[i-x,j-y] = image[i,j] #padding out of bounds entry with 256s test = window fraction_image = disk_window(test) reshaped = np.reshape(fraction_image, [fraction_image.shape[0]*fraction_image.shape[1]], order = 'F') # reshapes image to a single vector Complex = gudhi.CubicalComplex(dimensions=fraction_image.shape, top_dimensional_cells=reshaped) # creates the cubical complex from the image Complex.persistence() Dgm0=Complex.persistence_intervals_in_dimension(0) # compute oth dimensional persistence diagram Dgm1=Complex.persistence_intervals_in_dimension(1) # computes 1st dimensional persistenence diagram return Dgm0,Dgm1, fraction_image
from matplotlib import pyplot as plt N = 100 array = np.zeros((2*N+1,2*N+1)) xExtrem = 2; yExtrem = 2; bitmap = [] for i in range(0,2*N+1): for j in range (0,2*N+1): x = i/(2*float(N)+1)*2*float(xExtrem)-xExtrem y = j/(2*float(N)+1)*2*float(xExtrem)-xExtrem norm = math.sqrt( x*x + y*y ) norm = math.fabs(norm-1) array[i][j] = norm bitmap.append(norm) #Here we will display our creation: plt.imshow(array, cmap='gray', interpolation='nearest', vmin=np.amin(array), vmax=np.amax(array)) #plt.savefig('circle.png') plt.show() #Given the input data we can buld a Gudhi btmap cubical complex: bcc = gd.CubicalComplex(top_dimensional_cells = bitmap, dimensions=[2*N+1,2*N+1]) #optional computation of persistence #persistence = bcc.persistence() #plt = gd.plot_persistence_diagram(persistence) #plt.show()
else: IMG = [X[0][0][j] for j in range(len(X[0][0]))][::step] + [X[1][0][j] for j in range(len(X[1][0]))][::step] LAB = [X[0][1][j] for j in range(len(X[0][0]))][::step] + [X[1][1][j] for j in range(len(X[1][0]))][::step] ntrain = len(np.arange(len(X[0][0]))[::step]) train_idxs, test_idxs = np.arange(0, ntrain), np.arange(ntrain, len(IMG)) DGMb = [] for pdi in range(num_filts): DGMi = [] for j, img in enumerate(IMG): inds = np.argwhere(img > 0) I = np.inf * np.ones(img.shape) for i in range(len(inds)): val = np.cos(Cinit[pdi])*inds[i,0] + np.sin(Cinit[pdi])*inds[i,1] I[inds[i,0], inds[i,1]] = val ccb = gd.CubicalComplex(top_dimensional_cells=I) ccb.persistence() dgmb = ccb.persistence_intervals_in_dimension(hdim) DGMi.append(dgmb) if j == -1: vm, vM = min(list(I[I!=np.inf].flatten())), max(list(I[I!=np.inf].flatten())) plt.figure() plt.imshow(I, vmin=vm, vmax=vM) plt.colorbar() plt.savefig(str(j) + '_' + '{:.2f}'.format(Cinit[pdi]) + '.png') DGMb.append(DGMi) elif data_type == 'GRAPHS':