Upload folder using huggingface_hub

server-local/shortest-paths-terrain-patches/dataset/across-terrain-simulation.py

@@ -0,0 +1,132 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+from torch.utils.data import Dataset
+from torch_geometric.utils import to_networkx
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import os
+
+import argparse
+
+NSRCS = 100
+
+DATASET_INFO = {'norway': [10, False], 'phil': [3, True], 'holland': [1.524, True]}
+
+class SingleGraphShortestPathDataset(Dataset):
+    def __init__(self, sources, targets, lengths):
+        self.sources = sources
+        self.targets = targets
+        self.lengths = lengths
+
+    def __len__(self):
+        return len(self.sources)
+
+    def __getitem__(self, idx):
+        return self.sources[idx], self.targets[idx], self.lengths[idx]
+
+def single_source_sample(G, num_per_src, num_srcs):
+    number_of_nodes = G.number_of_nodes()
+    src_nodes = np.random.choice(number_of_nodes, size=NSRCS)
+    srcs = []
+    tars = []
+    lengths = []
+    for src in src_nodes:
+        shortest_paths = nx.single_source_dijkstra_path_length(G, s, weight='weight')
+        for i in trange(num_per_src):
+            t = np.random.choice(number_of_nodes)
+            srcs.append(s)
+            tars.append(t)
+            lengths.append(shortest_paths[t])
+    dataset = SingleGraphShortestPathDataset(sources = srcs, targets = tars, lengths = lengths)
+    return dataset
+
+def random_sample(G, num_sample):
+    number_of_nodes = G.number_of_nodes()
+    srcs = []
+    tars = []
+    lengths = []
+    for _ in trange(num_sample):
+        src, tar = np.random.choice(number_of_nodes, [2, ], replace=False)
+        length = nx.shortest_path_length(G, src, tar, weight='weight')
+        srcs.append(src)
+        tars.append(tar)
+        lengths.append(length)
+    dataset = SingleGraphShortestPathDataset(sources = srcs, targets = tars, lengths = lengths)
+    return dataset
+
+def construct_cross_terrains_dataset(nx_graphs, pyg_graphs, num_per_graph, sampling_technique='single_source_sample'):
+    dataset = {'graphs': pyg_graphs, 'datasets': []}
+    num_graphs = len(nx_graphs)
+
+    for i in range(num_graphs):
+        print("Processing graph:", i)
+        nx_graph = nx_graphs[i]
+        if sampling_technique == 'single_source_sample':
+            dataset['datasets'].append(single_source_sample(nx_graph, num_per_graph//NSRCS, NSRCS))
+        elif sampling_technique == 'random_sample':
+            dataset['datasets'].append(random_sample(nx_graph, num_per_graph))
+        else:
+            raise NotImplementedError('Other sampling techniques not implemented')
+    return dataset
+
+def npz_to_dataset(data):
+    
+    edge_index = torch.tensor(data['edge_index'], dtype=torch.long)
+
+    srcs = torch.tensor(data['srcs'])
+    tars = torch.tensor(data['tars'])
+    lengths = torch.tensor(data['lengths'])
+    node_features = torch.tensor(data['node_features'], dtype=torch.double)
+    edge_weights = torch.tensor(data['distances'])
+
+    return srcs, tars, lengths, node_features, edge_index, edge_weights
+
+def retrieve_artificial_dataset(file_pth):
+    # pth = f'/data/sam/terrain/data/artificial/change-heights/amp-{a}-res-{RES}-train-50k.npz'
+    # test_info = generate_train_data(pth, cnn_sz=100)
+    #amps = [1.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0]
+    amps = [2.0, 6.0,  10.0, 14.0,  18.0]
+    pyg_graphs = []
+    nx_graphs = []
+    for a in amps:
+        fname = os.path.join(file_pth, f'amp-{a}-res-2-train-50k.npz')
+        np_data = np.load(fname, allow_pickle=True)
+        _, _, _, node_features, edge_index, edge_weights = npz_to_dataset(np_data)
+        pyg_graph = Data(x =node_features, edge_index = edge_index, edge_attr = edge_weights)
+        nx_graph = to_networkx(pyg_graph)
+        for i in range(len(edge_index[0])):
+            v1 = edge_index[0][i].item()
+            v2 = edge_index[1][i].item()
+            nx_graph[v1][v2]['weight'] = pyg_graph.edge_attr[i].item()
+        nx_graphs.append(nx_graph)
+        pyg_graphs.append(pyg_graph)
+    return nx_graphs, pyg_graphs
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--dataset-name', type=str)
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str) # saves should be named `gr-{graph-resolution}-ps-{patch-size}-ol-{overlap}`
+    parser.add_argument('--graph-resolution', type=int)
+    parser.add_argument('--per-graph', type=int)
+    parser.add_argument('--patch-size', type=int)
+    parser.add_argument('--overlap', type=int)
+    parser.add_argument('--sampling-technique', type=str)
+
+    args = parser.parse_args()
+    if args.dataset_name != 'artificial':
+        raise NotImplementedError('Other datasets not implemented yet')
+    file_pth = '/data/sam/terrain/data/artificial/change-heights'
+    nx_graphs, pyg_graphs = retrieve_artificial_dataset(file_pth)
+    dataset = construct_cross_terrains_dataset(nx_graphs, 
+                                               pyg_graphs,
+                                               args.per_graph,
+                                               sampling_technique=args.sampling_technique)
+    torch.save(dataset, args.filename)
+
+if __name__ == '__main__':
+    main()

server-local/shortest-paths-terrain-patches/dataset/artificial_dem_array.py

@@ -0,0 +1,171 @@
+import numpy as np 
+import networkx as nx
+from tqdm import tqdm, trange
+import argparse
+import matplotlib.pyplot as plt
+
+
+def gaussian_2d(xv, yv, amplitude=1, center_x=0, center_y=0, sigma_x=1, sigma_y=1):
+    z1 = (xv - center_x)**2/(2*(sigma_x**2))
+    z2 = (yv - center_y)**2/(2*(sigma_y**2))
+    z = amplitude * np.exp(-(z1 + z2))
+    return z
+
+def create_elevation_array(n, k=10):
+    '''
+    Function which creates an n x n elevation array with k critical points
+
+    Returns: numpy array of elevations
+    '''
+    n0 = 10*n
+    # create x and y range
+    x = np.linspace(-10, 10, n0)
+    y = np.linspace(-10, 10, n0)
+    xv, yv = np.meshgrid(x, y)
+
+    z_out = np.zeros((n0, n0))
+    centers = [(50, 50), (200, 50), (50, 150), (250, 150), (130, 230)]
+    for i in range(k):
+        center = centers[i]
+        x_c = xv[center[0], center[1]]
+        y_c = yv[center[0], center[1]]
+        centers.append(center)
+        #a = np.random.uniform(low=1.0, high=5.0)
+        a = 3.0
+        # s_x = np.random.uniform(low=1.0, high=4.0)
+        # s_y = np.random.uniform(low=1.0, high=4.0)
+        s_x = 2.0
+        s_y = 2.0
+        z = gaussian_2d(xv, yv, amplitude=a, center_x = x_c, center_y = y_c, sigma_x=s_x, sigma_y=s_y)
+        z_out += z
+    return  z_out
+
+def get_array_neighbors_(x, y, left=0, right=500, radius=1):
+    temp = [(x - radius, y), (x + radius, y), (x, y - radius), (x, y + radius)]
+    neighbors = temp.copy()
+
+    for val in temp:
+        if val[0] < left or val[0] >= right:
+            neighbors.remove(val)
+        elif val[1] < left or val[1] >= right:
+            neighbors.remove(val)
+
+    return neighbors
+
+def construct_nx_graph(xv, yv, elevation, save_img=None):
+    sz = elevation.shape[0]
+    counts = np.reshape(np.arange(0, sz*sz), (sz, sz))
+    G = nx.Graph()
+
+    node_features = []
+    fig = plt.figure(figsize=(15, 15))
+    ax = fig.add_subplot(projection='3d')
+
+    for i in trange(0, len(elevation)):
+        for j in range(0, len(elevation)):
+            idx1 = counts[i, j]
+            G.add_node(idx1)
+            node_features.append(np.array([xv[i, j], yv[i, j], elevation[i, j]]))
+            neighbors = get_array_neighbors_(i, j, right=elevation.shape[0])
+            for n in neighbors:
+                p1 = np.array([xv[i, j], yv[i, j], elevation[i, j]])
+                p2 = np.array([xv[n[0], n[1]], yv[n[0], n[1]], elevation[n[0], n[1]]])
+                w = np.linalg.norm(p1 - p2)
+                if save_img != None:
+                    ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                idx2 = counts[n[0], n[1]]
+                G.add_edge(idx1, idx2, weight=w)
+    print("Size of graph:", len(node_features))
+    if save_img != None:
+        print("saved in:", save_img)
+        plt.savefig(save_img)
+    return G, node_features
+
+def get_elevated_points(node_features, threshhold=0.4):
+    elevated_pts = []
+    for i in range(len(node_features)):
+        z = node_features[i][2]
+        if z > 0.4:
+            elevated_pts.append(i)
+    return elevated_pts
+
+# at least guarantee_rough_path percent of the dataset should be go through "elevated points"
+def construct_pyg_dataset(G, node_features, filename, guarantee_rough_path = 0.2, size=100):
+    Nodes = np.sort(list(G.nodes()))
+
+    distances = []
+
+    edges = [[], []]
+
+    print("Formatting edge index.......")
+    for e in tqdm(G.edges(data=True)):
+        edges[0].append(e[0])
+        edges[1].append(e[1])
+        edges[0].append(e[1])
+        edges[1].append(e[0])
+
+        distances.append(e[2]['weight'])
+        distances.append(e[2]['weight'])
+    
+    # Get elevated points
+    elevated_pts = get_elevated_points(node_features, threshhold=0.6)
+
+    srcs = []
+    tars = []
+    lengths = []
+    print("Generating shortest paths......")
+    for i in range(len(Nodes)):
+        for j in range(i + 1, len(Nodes)):
+            src = i
+            tar = j
+            srcs.append(i)
+            tars.append(j)
+            length = nx.shortest_path_length(G, src, tar, weight='weight')
+            lengths.append(length)
+
+    # for i in trange(size):
+    #     if i < size*guarantee_rough_path and len(elevated_pts) > 0:
+    #         src = np.random.choice(elevated_pts)
+    #         tar = np.random.choice(len(node_features), replace=False)
+    #     else:
+    #         src, tar = np.random.choice(len(node_features), [2,], replace=False)
+    #     srcs.append(src)
+    #     tars.append(tar)
+    #     length = nx.shortest_path_length(G, src, tar, weight='weight')
+    #     lengths.append(length)
+    print("Saved dataset in:", filename)
+    np.savez(filename, 
+         edge_index = edges, 
+         distances=distances, 
+         nodes=Nodes,
+         srcs = srcs,
+         tars = tars,
+         lengths = lengths,
+         node_features=node_features)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--size", type=int)
+    parser.add_argument("--train-dataset-size", type=int)
+    parser.add_argument("--test-dataset-size", type=int)
+    args = parser.parse_args()
+
+    for k in range(1):
+        
+        upsample_save = f'/data/sam/terrain/data/artificial/for-lucas.npy'
+        xv, yv, dem, upsampled_dem = create_elevation_array(n=args.size, k=5)
+        np.save(upsample_save, upsampled_dem)
+        img = f'../images/small-k-{k}.png'
+        print("saved in", img)
+        # G, node_features = construct_nx_graph(xv, yv, dem, save_img=img)
+        # #for train_dataset_size in range(10000, 60000, 10000):
+        # train_filename = f'/data/sam/terrain/data/artificial/small-k-{k}-train-full.npz'
+        # construct_pyg_dataset(G, node_features, filename=train_filename, size=10)
+        # test_filename = f'/data/sam/terrain/data/artificial/small-k-{k}-test-{args.test_dataset_size}.npz'
+
+        
+        # construct_pyg_dataset(G, node_features, filename=test_filename, size=args.test_dataset_size)
+    return 0
+
+if __name__=="__main__":
+    main()

server-local/shortest-paths-terrain-patches/dataset/change-height-gen-dataset.py

@@ -0,0 +1,303 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import itertools
+
+import argparse
+import os
+
+DATASET_INFO = {'norway': [10, False], 'phil': [3, True], 'holland': [1.524, True], 'la': [28.34, False], 'artificial': [10/50, False]}
+
+# Load DEM data from file, 
+# outputs elevations in meters
+def load_dem_data_(filename, imperial=False):
+    f = open(filename)
+
+    lines = f.readlines()
+    arr = []
+    print("Elevation given in imperial units:", imperial)
+    c = 1
+    if imperial:
+        c = 3.28084
+    for i in range(1, len(lines)):
+        vals = lines[i].split()
+        a = []
+        for j in range(len(vals)):
+            a.append(float(vals[j])/c)
+        arr.append(a)
+    arr = np.array(arr)
+    print("loaded DEM array with shape:", arr.shape)
+    return arr
+
+def mesh_to_graph(edge_filename, vertex_filename):
+    f = open(edge_filename)
+    all_vertices = []
+    lines = f.readlines()
+    edges = []
+    for i in range(len(lines)):
+
+        vals = lines[i].split()
+        edges.append((int(vals[0]), int(vals[1])))
+        all_vertices.append(int(vals[0]))
+        all_vertices.append(int(vals[1]))
+    
+    unique_vertices = np.sort(np.unique(all_vertices))
+
+    nx_graph = nx.Graph()
+
+    temp = {}
+    for i in range(len(unique_vertices)):
+        temp[unique_vertices[i]] = i    
+    
+    f = open(vertex_filename)
+
+    lines = f.readlines()
+    vertices = np.zeros((len(unique_vertices), 3))
+    for i in range( len(lines)):
+        vals = lines[i].split()
+        vertices[i] = [ float(vals[0])/1000, float(vals[1])/1000, float(vals[2])/1000]
+
+    for i in range(len(edges)):
+        v1 = temp[edges[i][0]]
+        v2 = temp[edges[i][1]]
+        weight = np.linalg.norm(vertices[v1] - vertices[v2], ord=2)
+        nx_graph.add_edge(v1, v2, weight=weight)
+
+    return nx_graph, vertices
+
+# Get DEM array xloc and yloc
+# outputs all relevant values in km
+def get_dem_xv_yv_(arr, resolution, visualize=True):
+    sz = arr.shape[0]
+    total_width = resolution * sz
+    x = np.linspace(0, total_width, sz)
+    y = np.linspace(0, total_width, sz)
+    xv, yv = np.meshgrid(x, y)
+    if visualize == True:
+        plt.contourf(xv/1000, yv/1000, arr/1000)
+        print("minimal elevation:", np.min(arr), "maximum elevation:", np.max(arr))
+        plt.axis("scaled")
+        plt.colorbar()
+        plt.show()
+    return xv, yv, arr
+    #return xv/1000, yv/1000, arr/1000
+
+    
+# Construct grid
+def get_array_neighbors_(x, y, left=0, right=500, radius=1):
+    temp = [(x - radius, y), (x + radius, y), (x, y - radius), (x, y + radius)]
+    neighbors = temp.copy()
+
+    for val in temp:
+        if val[0] < left or val[0] >= right:
+            neighbors.remove(val)
+        elif val[1] < left or val[1] >= right:
+            neighbors.remove(val)
+
+    return neighbors
+
+# External use ok
+def construct_nx_graph(xv, yv, elevation, triangles=False, p=2, scale=False):
+    
+    n = elevation.shape[0]
+    m = elevation.shape[1]
+    print("shape", n, m)
+    counts = np.reshape(np.arange(0, n*m), (n, m))
+    G = nx.Graph()
+
+    print(triangles)
+
+    node_features = []
+    #fig = plt.figure()
+    #ax = fig.add_subplot(projection='3d')
+    for i in trange(0, n):
+        for j in range(0, m):
+            idx1 = counts[i, j]
+            G.add_node(idx1)
+            node_features.append(np.array([xv[i, j], yv[i, j], elevation[i, j]]))
+            neighbors = get_array_neighbors_(i, j, right=elevation.shape[0], radius=1)
+            for neighbor in neighbors:
+                p1 = np.array([xv[i, j], yv[i, j], elevation[i, j]])
+                p2 = np.array([xv[neighbor[0], neighbor[1]], yv[neighbor[0], neighbor[1]], elevation[neighbor[0], neighbor[1]]])
+                if scale:
+                    angle_of_elevation = np.abs(np.arctan(p1[2] - p2[2])/np.linalg.norm(p2[:2] - p1[:2], ord=2))
+                    # slope = (abs(p1[2] - p2[2]))/(abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]))
+                    # w = 1+ np.log(1 + slope)
+                    w = angle_of_elevation * np.linalg.norm(p1 - p2, ord=p)
+                else:
+                    w = np.linalg.norm(p1 - p2, ord=p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                idx2 = counts[neighbor[0], neighbor[1]]
+                G.add_edge(idx1, idx2, weight=w)
+    print("Size of graph:", len(node_features))
+    if triangles:
+        for i in trange(0, n - 1):
+            for j in range(0, m - 1):
+                # index cell by top left coordinate
+                triangle_edge = [(counts[i, j], counts[i + 1, j + 1]), (counts[i + 1, j], counts[i, j + 1])]
+                edge = triangle_edge[np.random.choice(2)]
+                for edge in triangle_edge:
+                    p1 = node_features[edge[0]]
+                    p2 = node_features[edge[1]]
+                    if scale:
+                        angle_of_elevation = np.abs(np.arctan(p1[2] - p2[2])/np.linalg.norm(p2[:2] - p1[:2], ord=2))
+                        w = angle_of_elevation * np.linalg.norm(p1 - p2, ord=p)
+                    else:  
+                        w = np.linalg.norm(p1 - p2, ord = p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                    G.add_edge(edge[0], edge[1], weight=w)
+    #fig.savefig('../images/norway-250.png')
+    print(G.edges(0))
+    return G, node_features
+
+def to_pyg_graph(G):
+    distances = []
+
+    edges = [[], []]
+
+    print("Formatting edge index.......")
+    for e in tqdm(G.edges(data=True)):
+        edges[0].append(e[0])
+        edges[1].append(e[1])
+        edges[0].append(e[1])
+        edges[1].append(e[0])
+
+        distances.append(e[2]['weight'])
+        distances.append(e[2]['weight'])
+    return edges, distances
+    
+def generate_probabilities(N, m):
+    all_pairs = list(itertools.combinations(range(N), 2))
+    probabilities = []
+    for src, tar in tqdm(all_pairs):
+        hops = abs(src//m - tar//m) + abs(src % m - tar % m )
+        probabilities.append(1/(hops**2) if hops > 0 else 1)
+    return all_pairs, probabilities
+
+def construct_pyg_dataset(G, node_features, filename, size=100, sampling_technique='distance-based', m=10, p=0.10):
+    Nodes = np.sort(list(G.nodes()))
+
+    edges, distances = to_pyg_graph(G)
+    
+    srcs = []
+    tars = []
+    lengths = []
+    print("Generating shortest paths......")
+    #jobs = []
+    #pool = mp.Pool(processes=20)
+    node_idxs = np.reshape(np.arange(m * m), (m, m))
+    lst= np.arange(len(node_features))
+    print(sampling_technique)
+    for i in trange(size):
+        if sampling_technique == 'distance-based':
+            src = np.random.choice(len(node_features))
+            hops = abs(src//m - lst//m) + abs(src % m - lst % m)+ 1
+            probs = 1/hops
+            probs = probs/np.linalg.norm(probs, ord=1)
+            tar = np.random.choice(len(node_features), p = probs)
+        elif sampling_technique == 'constrained-125x125':
+            src = np.random.choice(len(node_features))
+            src_row = src//m
+            src_col = src %m 
+            if np.random.uniform(low=0.0, high=1.0) <= p:
+                tar = np.random.choice(len(node_features))
+            else:
+                b1 = 0 if src_row -125  < 0 else src_row - 125
+                b2 = 0 if src_col - 125 < 0 else src_col - 125
+                #print(b1, src_row + 25, b2, src_col + 25, node_idxs[b1 : src_row + 25, b2: src_col+25].flatten())
+                tar = np.random.choice(node_idxs[b1 : src_row + 125, b2: src_col+125].flatten())
+        elif sampling_technique == 'constrained-25x25':
+            src = np.random.choice(len(node_features))
+            src_row = src//m
+            src_col = src %m 
+            p = np.random.uniform(low=0.0, high=1.0)
+            if p > 1.0:
+                tar = np.random.choice(len(node_features))
+            else:
+                b1 = 0 if src_row -25  < 0 else src_row - 25
+                b2 = 0 if src_col - 25 < 0 else src_col - 25
+                tar = np.random.choice(node_idxs[b1 : src_row + 25, b2: src_col+25].flatten())
+        elif sampling_technique == 'ss-random':
+            num_tars = size // 100
+            src_nodes = np.random.choice(len(node_features), size=100)
+            tars = []
+            srcs = []
+            lengths = []
+            for s in tqdm(src_nodes):
+                shortest_paths = nx.single_source_dijkstra_path_length(G, s, weight='weight')
+                for i in range(num_tars):
+                    t = np.random.choice(len(node_features))
+                    srcs.append(s)
+                    tars.append(t)
+                    lengths.append(shortest_paths[t])
+            break
+        else:
+            src, tar = np.random.choice(len(node_features), [2, ], replace=False)
+        if sampling_technique != 'ss-random':
+            length = nx.shortest_path_length(G, src, tar, weight='weight')
+            srcs.append(src)
+            tars.append(tar)
+            lengths.append(length)
+    # rotation = np.array([[np.cos(np.pi/9), -np.sin(np.pi/9)], [np.sin(np.pi/9), np.cos(np.pi/9)]])
+    # node_features = np.array(node_features)
+    # rotated_pts_x_y = (rotation @ node_features[:, :2].T).T
+    # node_features[:, :2] = rotated_pts_x_y
+    print("Saved dataset in:", filename)
+    np.savez(filename, 
+         edge_index = edges, 
+         distances=distances, 
+         nodes=Nodes,
+         srcs = srcs,
+         tars = tars,
+         lengths = lengths,
+         node_features=node_features)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--name', type=str)
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str)
+    parser.add_argument('--graph-resolution', type=int)
+    parser.add_argument('--dataset-size', type=int)
+    parser.add_argument('--sampling-technique', type=str, default='random')
+    parser.add_argument('--triangles', action='store_true')
+    parser.add_argument('--edge-weight', action='store_true')
+
+    args = parser.parse_args()
+    dem_res = DATASET_INFO[args.name][0]
+    imperial = DATASET_INFO[args.name][1]
+    AMPS = [1.0, 2.0, 4.0, 6.0, 8.0, 9.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0]
+    for amp in AMPS:
+        raw_data = f'/data/sam/terrain/data/artificial/change-heights/amp-{amp}.npy'
+        dem_array = np.load(raw_data)
+        xv, yv, elevations = get_dem_xv_yv_(dem_array, dem_res)
+
+        res = args.graph_resolution
+        
+        filename = args.filename
+        
+        xv_n = xv[::res, ::res]
+        yv_n = yv[::res, ::res]
+        elevations_n = elevations[::res, ::res]
+        m = elevations_n.shape[1]
+        print('terrain shape:', elevations.shape)
+        
+        G, node_features = construct_nx_graph(xv_n, yv_n, elevations_n, triangles=args.triangles, scale=args.edge_weight)
+        filename = f'{args.filename}/amp-{amp}-res-{res}-train-{args.dataset_size//1000}k.npz'
+        sz = args.dataset_size
+        sampling_technique = args.sampling_technique
+        construct_pyg_dataset(G, 
+                            node_features, 
+                            filename, 
+                            size=sz, 
+                            sampling_technique=sampling_technique,
+                            m = 10)
+
+
+if __name__ == '__main__':
+    main()

server-local/shortest-paths-terrain-patches/dataset/change-heights-dem.py

@@ -0,0 +1,59 @@
+import numpy as np 
+import networkx as nx
+from tqdm import tqdm, trange
+import argparse
+import matplotlib.pyplot as plt
+
+
+## Fix centers
+## Change amplitude of Gaussians 
+## Save several datasets 
+## Run training on the <downsampled version> of the datasets
+
+def gaussian_2d(xv, yv, amplitude=1, center_x=0, center_y=0, sigma_x=1, sigma_y=1):
+    z1 = (xv - center_x)**2/(2*(sigma_x**2))
+    z2 = (yv - center_y)**2/(2*(sigma_y**2))
+    z = amplitude * np.exp(-(z1 + z2))
+    return z
+
+def create_artificial_dem(xv, yv, centers, amp=2.0):
+    z_out = np.zeros((xv.shape[0], xv.shape[1]))
+    for i in range(len(centers)):
+        x_c = centers[i][0]
+        y_c = centers[i][1]
+        
+        z = gaussian_2d(xv, yv, amplitude=amp, center_x = x_c, center_y = y_c, sigma_x = 1.0, sigma_y = 1.0)
+        z_out += z
+    return z_out
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--amplitudes", type=float, nargs='+')
+    parser.add_argument("--size", type=int)
+    args = parser.parse_args()
+    n = args.size 
+    # create x and y range
+    x = np.linspace(0, 10, n)
+    y = np.linspace(0, 10, n)
+    xv, yv = np.meshgrid(x, y)
+
+    fig =plt.figure(figsize=(40, 5))
+    ax_ct = 1
+    centers = np.random.choice(x, size=(15, 2))
+    for amp in args.amplitudes:
+        name=f'/data/sam/terrain/data/artificial/change-heights/amp-{amp}.npy'
+        
+        img = create_artificial_dem(xv, yv, centers, amp)
+
+        np.save(name, img)
+
+        ax = fig.add_subplot(1, len(args.amplitudes), ax_ct, projection='3d')
+
+        ax.plot_surface(xv, yv, img)
+        ax.set_zlim(0, 20)
+        ax_ct += 1
+    fig.savefig('changing-heights.png')
+    return 0
+
+if __name__=="__main__":
+    main()

server-local/shortest-paths-terrain-patches/dataset/dataset.py

@@ -0,0 +1,313 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import itertools
+
+import argparse
+import os
+from point_sampler import * 
+
+DATASET_INFO = {'norway': [10, False], 
+                'phil': [3, True], 
+                'holland': [1.524, True], 
+                'la': [28.34, False], 
+                'artificial': [10/50, False]}
+
+# Load DEM data from file, 
+# outputs elevations in meters
+def load_dem_data_(filename, imperial=False):
+    f = open(filename)
+
+    lines = f.readlines()
+    arr = []
+    print("Elevation given in imperial units:", imperial)
+    c = 1
+    if imperial:
+        c = 3.28084
+    for i in range(1, len(lines)):
+        vals = lines[i].split()
+        a = []
+        for j in range(len(vals)):
+            a.append(float(vals[j])/c)
+        arr.append(a)
+    arr = np.array(arr)
+    print("loaded DEM array with shape:", arr.shape)
+    return arr
+
+def mesh_to_graph(edge_filename, vertex_filename):
+    f = open(edge_filename)
+    all_vertices = []
+    lines = f.readlines()
+    edges = []
+    for i in range(len(lines)):
+
+        vals = lines[i].split()
+        edges.append((int(vals[0]), int(vals[1])))
+        all_vertices.append(int(vals[0]))
+        all_vertices.append(int(vals[1]))
+    
+    unique_vertices = np.sort(np.unique(all_vertices))
+
+    nx_graph = nx.Graph()
+
+    temp = {}
+    for i in range(len(unique_vertices)):
+        temp[unique_vertices[i]] = i    
+    
+    f = open(vertex_filename)
+
+    lines = f.readlines()
+    vertices = np.zeros((len(unique_vertices), 3))
+    for i in range( len(lines)):
+        vals = lines[i].split()
+        vertices[i] = [ float(vals[0])/1000, float(vals[1])/1000, float(vals[2])/1000]
+
+    for i in range(len(edges)):
+        v1 = temp[edges[i][0]]
+        v2 = temp[edges[i][1]]
+        weight = np.linalg.norm(vertices[v1] - vertices[v2], ord=2)
+        nx_graph.add_edge(v1, v2, weight=weight)
+
+    return nx_graph, vertices
+
+# Get DEM array xloc and yloc
+# outputs all relevant values in km
+def get_dem_xv_yv_(arr, resolution, visualize=True):
+    sz = arr.shape[0]
+    total_width = resolution * sz
+    x = np.linspace(0, total_width, sz)
+    y = np.linspace(0, total_width, sz)
+    xv, yv = np.meshgrid(x, y)
+    if visualize == True:
+        plt.contourf(xv/1000, yv/1000, arr/1000)
+        print("minimal elevation:", np.min(arr), "maximum elevation:", np.max(arr))
+        plt.axis("scaled")
+        plt.colorbar()
+        plt.show()
+    #return xv, yv, arr
+    return xv/1000, yv/1000, arr/1000
+
+    
+# Construct grid with both cross edges
+def get_array_neighbors_(x, y, left=0, right=500, radius=1):
+    temp = [(x - radius, y), 
+            (x + radius, y), 
+            (x, y - radius), 
+            (x, y + radius), 
+            (x - radius, y - radius), 
+            (x - radius, y + radius), 
+            (x + radius, y - radius), 
+            (x+radius, y + radius)]
+    neighbors = temp.copy()
+
+    for val in temp:
+        if val[0] < left or val[0] >= right:
+            neighbors.remove(val)
+        elif val[1] < left or val[1] >= right:
+            neighbors.remove(val)
+
+    return neighbors
+
+# External use ok
+def construct_nx_graph(xv, yv, elevation, triangles=False, p=2, scale=False):
+    
+    n = elevation.shape[0]
+    m = elevation.shape[1]
+    print("shape", n, m)
+    counts = np.reshape(np.arange(0, n*m), (n, m))
+    G = nx.Graph()
+
+    print(triangles)
+
+    node_features = []
+    #fig = plt.figure()
+    #ax = fig.add_subplot(projection='3d')
+    for i in trange(0, n):
+        for j in range(0, m):
+            idx1 = counts[i, j]
+            G.add_node(idx1)
+            node_features.append(np.array([xv[i, j], yv[i, j], elevation[i, j]]))
+            neighbors = get_array_neighbors_(i, j, right=elevation.shape[0], radius=1)
+            for neighbor in neighbors:
+                p1 = np.array([xv[i, j], yv[i, j], elevation[i, j]])
+                p2 = np.array([xv[neighbor[0], neighbor[1]], yv[neighbor[0], neighbor[1]], elevation[neighbor[0], neighbor[1]]])
+                if scale:
+                    val = abs(np.random.normal(1.0, 1.0))
+                    slope = (abs(p1[2] - p2[2]))/(abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]))
+                    angle_of_elevation = np.abs(np.arctan(p1[2] - p2[2])/np.linalg.norm(p2[:2] - p1[:2], ord=2))
+                    val = angle_of_elevation
+                    w = (1 + val) * np.linalg.norm(p1 - p2, ord=p)
+                else:
+                    w = np.linalg.norm(p1 - p2, ord=p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                idx2 = counts[neighbor[0], neighbor[1]]
+                G.add_edge(idx1, idx2, weight=w)
+    print("Number of nodes:", len(node_features))
+    print("Number of edges:", G.number_of_edges())
+    print(G.edges(0))
+    return G, node_features
+
+def to_pyg_graph(G):
+    distances = []
+
+    edges = [[], []]
+
+    print("Formatting edge index.......")
+    for e in tqdm(G.edges(data=True)):
+        edges[0].append(e[0])
+        edges[1].append(e[1])
+        edges[0].append(e[1])
+        edges[1].append(e[0])
+
+        distances.append(e[2]['weight'])
+        distances.append(e[2]['weight'])
+    return edges, distances
+    
+def generate_probabilities(N, m):
+    all_pairs = list(itertools.combinations(range(N), 2))
+    probabilities = []
+    for src, tar in tqdm(all_pairs):
+        hops = abs(src//m - tar//m) + abs(src % m - tar % m )
+        probabilities.append(1/(hops**2) if hops > 0 else 1)
+    return all_pairs, probabilities
+
+
+def construct_dataset(G,
+                      node_features, 
+                      filename, 
+                      sampling_method, 
+                      num_srcs, 
+                      samples_per_source, 
+                      rows=100, 
+                      cols=100, 
+                      threshhold=0.2):
+    edges, distances = to_pyg_graph(G)
+    
+    if sampling_method == 'single-source-random':
+        src_nodes = np.random.choice(len(node_features), size=num_srcs)
+        sampling_fn = random_sampling
+    elif sampling_method == 'critical-point-source':
+        node_features = np.array(node_features)
+        c1 = node_features[:, 0].reshape(rows, cols)
+        c2 = node_features[:, 1].reshape(rows, cols)
+        c3 = node_features[:, 2].reshape(rows, cols)
+        terrain = torch.tensor(np.stack([c1, c2, c3]), dtype=torch.float)
+        terrain = np.transpose(terrain, (1, 2, 0))
+        print(terrain.size())
+        src_nodes = find_critical_points(terrain, threshhold)
+        sampling_fn = random_sampling
+    elif sampling_method == 'distance-based':
+        src_nodes = np.random.choice(len(node_features), size=num_srcs)
+        sampling_fn = distance_based
+    else:
+        raise NotImplementedError("please choose between 'single-source-random', 'critical-point-source', 'distance-based'")
+    srcs = []
+    tars = []
+    lengths = []
+    print("Number of source nodes:", len(src_nodes))
+    print("Generating shortest path distances.....")
+    for src in tqdm(src_nodes):
+        source, target, length = sampling_fn(G, samples_per_source, src=src)
+        srcs += source
+        tars += target
+        lengths += length
+    print("Number of lengths in dataset:", len(lengths))
+    print("Saved dataset in:", filename)
+    np.savez(filename, 
+         edge_index = edges, 
+         distances=distances, 
+         srcs = srcs,
+         tars = tars,
+         lengths = lengths,
+         node_features=node_features)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--name', type=str)
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str)
+    parser.add_argument('--graph-resolution', type=int)
+    parser.add_argument('--dataset-size', type=int)
+    parser.add_argument('--num-sources', type=int)
+    parser.add_argument('--sampling-technique', type=str, default='random')
+    parser.add_argument('--triangles', action='store_true')
+    parser.add_argument('--edge-weight', action='store_true')
+    parser.add_argument('--change-heights', action='store_true')
+    parser.add_argument('--critical-point-threshhold', type=float, default=0.2)
+
+    args = parser.parse_args()
+    dem_res = DATASET_INFO[args.name][0]
+    imperial = DATASET_INFO[args.name][1]
+    if 'meshes' in args.raw_data:
+        edge_filename = os.path.join(args.raw_data, 'percent_edges')
+        vertex_filename = os.path.join(args.raw_data, 'percent_vertices')
+        G, node_features = mesh_to_graph(edge_filename, vertex_filename)
+        m = 10
+    else:
+        if args.name == 'la' or args.name == 'artificial':
+            dem_array = np.load(args.raw_data)
+        else:
+            dem_array = load_dem_data_(args.raw_data, imperial)
+        xv, yv, elevations = get_dem_xv_yv_(dem_array, dem_res)
+        row,col = np.random.choice(elevations.shape[0], size=[2,])
+        res = args.graph_resolution
+        
+        filename = args.filename
+        
+        xv_n = xv[::res, ::res]
+        yv_n = yv[::res, ::res]
+        elevations_n = elevations[::res, ::res]
+        print(np.min(elevations_n))
+        print('terrain shape:', elevations_n.shape)
+        print('resolution:', res)
+        if args.change_heights:
+            for k in range(1, 60):
+                filename = f'/data/sam/terrain/data/{args.name}/uncertainty/50/50k-{k}.npz'
+                uncertainty = np.random.uniform(-0.050, 0.050, size=elevations_n.shape)
+                elevations_n = uncertainty + elevations_n
+                
+                G, node_features = construct_nx_graph(xv_n, 
+                                                      yv_n, 
+                                                      elevations_n, 
+                                                      triangles=args.triangles, 
+                                                      scale=args.edge_weight)
+                sz = args.dataset_size
+                sampling_technique = args.sampling_technique
+                
+                construct_dataset(G = G, 
+                                  node_features = node_features, 
+                                  filename = filename, 
+                                  num_srcs = args.num_sources,
+                                  samples_per_source = args.dataset_size//args.num_sources,
+                                  sampling_method=sampling_technique,
+                                  rows = elevations_n.shape[0],
+                                  cols = elevations_n.shape[1], 
+                                  threshhold = args.critical_point_threshhold)
+        else:
+            G, node_features = construct_nx_graph(xv_n, 
+                                                  yv_n, 
+                                                  elevations_n, 
+                                                  triangles=args.triangles, 
+                                                  scale=args.edge_weight)
+            filename = args.filename
+            sz = args.dataset_size
+            sampling_technique = args.sampling_technique
+            
+            construct_dataset(G = G, 
+                                  node_features = node_features, 
+                                  filename = filename, 
+                                  num_srcs = args.num_sources,
+                                  samples_per_source = args.dataset_size//args.num_sources,
+                                  sampling_method=sampling_technique,
+                                  rows = elevations_n.shape[0],
+                                  cols = elevations_n.shape[1], 
+                                  threshhold = args.critical_point_threshhold)
+
+
+if __name__ == '__main__':
+    main()

server-local/shortest-paths-terrain-patches/dataset/generate-test-dataset.py

@@ -0,0 +1,294 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import itertools
+
+import argparse
+
+DATASET_INFO = {'norway': [10, False], 'phil': [3, True], 'holland': [1.524, True], 'la': [28.34, False]}
+
+# Load DEM data from file, 
+# outputs elevations in meters
+def load_dem_data_(filename, imperial=False):
+    f = open(filename)
+
+    lines = f.readlines()
+    arr = []
+    print("Elevation given in imperial units:", imperial)
+    c = 1
+    if imperial:
+        c = 3.28084
+    for i in range(1, len(lines)):
+        vals = lines[i].split()
+        a = []
+        for j in range(len(vals)):
+            a.append(float(vals[j])/c)
+        arr.append(a)
+    arr = np.array(arr)
+    print("loaded DEM array with shape:", arr.shape)
+    return arr
+
+# Get DEM array xloc and yloc
+# outputs all relevant values in km
+def get_dem_xv_yv_(arr, resolution, visualize=True):
+    sz = arr.shape[0]
+    total_width = resolution * sz
+    x = np.linspace(0, total_width, sz)
+    y = np.linspace(0, total_width, sz)
+    xv, yv = np.meshgrid(x, y)
+    if visualize == True:
+        plt.contourf(xv/1000, yv/1000, arr/1000)
+        print("minimal elevation:", np.min(arr/1000), "maximum elevation:", np.max(arr/1000))
+        plt.axis("scaled")
+        plt.colorbar()
+        plt.show()
+    #return xv, yv, arr
+    return xv/1000, yv/1000, arr/1000
+
+    
+# Construct grid
+def get_array_neighbors_(x, y, left=0, right=500, radius=1):
+    temp = [(x - radius, y), (x + radius, y), (x, y - radius), (x, y + radius)]
+    neighbors = temp.copy()
+
+    for val in temp:
+        if val[0] < left or val[0] >= right:
+            neighbors.remove(val)
+        elif val[1] < left or val[1] >= right:
+            neighbors.remove(val)
+
+    return neighbors
+
+# External use ok
+def construct_nx_graph(xv, yv, elevation, triangles=False, p=2):
+    
+    n = elevation.shape[0]
+    m = elevation.shape[1]
+    print("shape", n, m)
+    counts = np.reshape(np.arange(0, n*m), (n, m))
+    G = nx.Graph()
+
+    node_features = []
+    #fig = plt.figure()
+    #ax = fig.add_subplot(projection='3d')
+    for i in trange(0, n):
+        for j in range(0, m):
+            idx1 = counts[i, j]
+            G.add_node(idx1)
+            node_features.append(np.array([xv[i, j], yv[i, j], elevation[i, j]]))
+            neighbors = get_array_neighbors_(i, j, right=elevation.shape[0], radius=1)
+            for neighbor in neighbors:
+                p1 = np.array([xv[i, j], yv[i, j], elevation[i, j]])
+                p2 = np.array([xv[neighbor[0], neighbor[1]], yv[neighbor[0], neighbor[1]], elevation[neighbor[0], neighbor[1]]])
+                w = np.linalg.norm(p1 - p2, ord=p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                idx2 = counts[neighbor[0], neighbor[1]]
+                G.add_edge(idx1, idx2, weight=w)
+    print("Size of graph:", len(node_features))
+    if triangles:
+        for i in trange(0, n - 1):
+            for j in range(0, m - 1):
+                # index cell by top left coordinate
+                triangle_edge = [(counts[i, j], counts[i + 1, j + 1]), (counts[i + 1, j], counts[i, j + 1])]
+                for edge in triangle_edge:
+                    p1 = node_features[edge[0]]
+                    p2 = node_features[edge[1]]
+                    w = np.linalg.norm(p1 - p2, ord = p)
+                    G.add_edge(edge[0], edge[1], weight=w)
+    #fig.savefig('../images/norway-250.png')
+    return G, node_features
+
+def to_pyg_graph(G):
+    distances = []
+
+    edges = [[], []]
+
+    print("Formatting edge index.......")
+    for e in tqdm(G.edges(data=True)):
+        edges[0].append(e[0])
+        edges[1].append(e[1])
+        edges[0].append(e[1])
+        edges[1].append(e[0])
+
+        distances.append(e[2]['weight'])
+        distances.append(e[2]['weight'])
+    return edges, distances
+    
+def generate_probabilities(N, m):
+    all_pairs = list(itertools.combinations(range(N), 2))
+    probabilities = []
+    for src, tar in tqdm(all_pairs):
+        hops = abs(src//m - tar//m) + abs(src % m - tar % m )
+        probabilities.append(1/(hops**2) if hops > 0 else 1)
+    return all_pairs, probabilities
+
+def get_neighbors(center, n=1):
+    ret = []
+    for dx in range(-n, n + 1):
+        ydiff = n - abs(dx)
+        for dy in range(-ydiff, ydiff + 1):
+            ret.append((center[0] + dx, center[1] + dy))
+    return ret
+
+# n = rows
+# m = columns
+def generate_src_tar_pairs(node_features, n, m, size=100, sampling_technique='random'):
+    num_nodes = len(node_features)
+    node_idxs = np.reshape(np.arange(n * m), (n, m))
+    tars = []
+    if sampling_technique == 'random':
+        srcs = np.random.choice(np.arange(num_nodes), size = size)
+        tars = np.random.choice(np.arange(num_nodes), size = size)
+    elif sampling_technique == 'expanding-radius':
+        radii = [60, 100, 120, 140, 160, 200]
+        num_per_radius = 20
+        num_srcs = size // (len(radii) * num_per_radius)
+        srcs = np.random.choice(np.arange(num_nodes), size = num_srcs)
+        for s in srcs:
+            x_loc = s//n
+            y_loc = s % m
+            for r in radii: 
+                # collect all nodes at radii 5
+                nodes_at_radii = get_neighbors((x_loc, y_loc), n=r)
+                for i in range(num_per_radius):
+                    node = nodes_at_radii[np.random.choice(len(nodes_at_radii), replace = False)]
+                    if node[0] >= n or node[0] < 0:
+                        continue
+                    if node[1] >= m or node[1] < 0:
+                        continue
+                    tar = node_idxs[node[0], node[1]]
+                    tars.append(tar)
+    # sample sources from top 100 height points. 
+    elif sampling_technique == 'height-sensitive-random':
+        node_features = np.array(node_features)
+        sorted_height_array = np.argsort(node_features[:, 2])
+        num_srcs = 10
+        num_per_src = int(size//20)
+        srcs = []
+        src_nodes = np.random.choice(sorted_height_array[-1000000:], size = num_srcs)
+        for s in tqdm(src_nodes):
+            tar_nodes = np.random.choice(len(node_features), size=num_per_src)
+            for t in tar_nodes:
+                tars.append(t)
+                srcs.append(s)
+    # check that all src, target nodes are in the graph
+    for i in range(len(srcs)):
+        assert srcs[i] >= 0 and srcs[i] < len(node_features)
+        assert tars[i] >=0 and tars[i] < len(node_features)
+    return srcs, tars
+
+def single_src_dataset(G, node_features, filename, size=100):
+    num_nodes = len(node_features)
+    lengths = []
+    srcs = []
+    tars = []
+    node_features = np.array(node_features)
+    sorted_height_array = np.argsort(node_features[:, 2])
+    num_srcs = 10
+    src_nodes = np.random.choice(sorted_height_array[-1000000:], size = num_srcs)
+    for i in trange(len(src_nodes)):
+        #src = np.random.choice(num_nodes)
+        src = src_nodes[i]
+        all_pairs_shortest_paths = nx.single_source_dijkstra_path_length(G, src, weight='weight')
+        for tar in all_pairs_shortest_paths:
+            tars.append(tar)
+            srcs.append(src)
+            lengths.append(all_pairs_shortest_paths[tar])
+
+    return srcs, tars, lengths
+
+def construct_pyg_dataset(G, node_features, filename, size=100, distance_based=False, m=10):
+    Nodes = np.sort(list(G.nodes()))
+
+    edges, distances = to_pyg_graph(G)
+    
+    srcs = []
+    tars = []
+    lengths = []
+    print("Generating shortest paths......")
+    #jobs = []
+    #pool = mp.Pool(processes=20)
+    srcs, tars, lengths = single_src_dataset(G, node_features, filename, size=size)
+    # samples = np.random.choice(len(srcs), size=100000, replace=False)
+    srcs = np.array(srcs)
+    tars = np.array(tars)
+    lengths = np.array(lengths)
+    # srcs, tars = generate_src_tar_pairs(node_features, m, m, size = size, sampling_technique = 'random')
+    # for i in trange(len(srcs)):
+    #     s = srcs[i]
+    #     t = tars[i]
+    #     length = nx.shortest_path_length(G, s, t, weight='weight')
+    #     lengths.append(length)
+
+    print("Saved dataset in:", filename)
+    np.savez(filename, 
+         edge_index = edges, 
+         distances=distances, 
+         nodes=Nodes,
+         srcs = srcs,
+         tars = tars,
+         lengths = lengths,
+         node_features=node_features)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--name', type=str)
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str)
+    parser.add_argument('--graph-resolution', type=int)
+    parser.add_argument('--dataset-size', type=int)
+    parser.add_argument('--distance-based-sampling', action='store_true')
+    parser.add_argument('--triangles', action='store_true')
+
+    args = parser.parse_args()
+    dem_res = DATASET_INFO[args.name][0]
+    imperial = DATASET_INFO[args.name][1]
+    if args.name == 'la':
+        dem_array = np.load(args.raw_data)
+    else:
+        dem_array = load_dem_data_(args.raw_data, imperial)
+    xv, yv, elevations = get_dem_xv_yv_(dem_array, dem_res)
+    # row,col = np.random.choice(elevations.shape[0], size=[2,])
+    # print(row, col)
+    # Norway
+    # row = 122 
+    # col = 1647
+    ## Philadelphia
+    # row = 181 
+    # col = 613
+    ## holland 
+    # row = 439 
+    # col = 471
+    ## L A
+    # 624 510
+    # row = 624
+    # col = 512
+    # xv_n = xv[row:row+ 100, col:col+100]
+    # yv_n = yv[row:row+100, col:col+100]
+    # elevations_n = elevations[row:row+100, col:col+100]
+    
+    res = args.graph_resolution
+    sz = args.dataset_size
+    filename = args.filename
+    xv_n = xv[::res, ::res]
+    yv_n = yv[::res, ::res]
+    elevations_n = elevations[::res, ::res]
+    print('terrain shape:', elevations.shape)
+
+    G, node_features = construct_nx_graph(xv_n, yv_n, elevations_n, triangles=args.triangles)
+    
+    construct_pyg_dataset(G, 
+                        node_features, 
+                        filename, 
+                        size=sz, 
+                        distance_based=args.distance_based_sampling,
+                        m = elevations_n.shape[1])
+
+
+if __name__ == '__main__':
+    main()

server-local/shortest-paths-terrain-patches/dataset/patch_dataset.py

@@ -0,0 +1,261 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import os
+
+import argparse
+
+DATASET_INFO = {'norway': [10, False], 'phil': [3, True], 'holland': [1.524, True], 'la': [28.34, False]}
+
+
+class TerrainPatchesData(Data):
+    def __inc__(self, key, value, *args, **kwargs):
+        if key == 'src':
+            return self.x.size(0)
+        if key == 'tar':
+            return self.x.size(0)
+        return super().__inc__(key, value, *args, **kwargs)
+
+# Load DEM data from file
+def load_dem_data_(filename, imperial=False):
+    f = open(filename)
+
+    lines = f.readlines()
+    arr = []
+    print("Elevation given in imperial units:", imperial)
+    c = 1
+    if imperial:
+        c = 3.28084
+    for i in range(1, len(lines)):
+        vals = lines[i].split()
+        a = []
+        for j in range(len(vals)):
+            a.append(float(vals[j])/c)
+        arr.append(a)
+    arr = np.array(arr)
+    print("loaded DEM array with shape:", arr.shape)
+    return arr
+
+# Get DEM array xloc and yloc
+def get_dem_xv_yv_(arr, resolution, visualize=True):
+    x_sz = arr.shape[0]
+    total_width_x = resolution * x_sz
+    y_sz = arr.shape[1]
+    total_width_y = resolution * y_sz
+    x = np.linspace(0, total_width_x, x_sz)
+    y = np.linspace(0, total_width_y, y_sz)
+    xv, yv = np.meshgrid(x, y, indexing='ij')
+    if visualize == True:
+        plt.contourf(xv/1000, yv/1000, arr/1000, origin='upper')
+        print("minimum elevation:", np.min(arr/1000), "maximum elevation:", np.max(arr/1000))
+        plt.axis("scaled")
+        plt.colorbar()
+        plt.savefig('la-county-contour')
+    return xv/1000, yv/1000, arr/1000
+
+    
+# Construct grid
+def get_array_neighbors_(x, y, left=0, right=500, top=0, bottom=500, radius=1):
+    temp = [(x - radius, y), (x + radius, y), (x, y - radius), (x, y + radius)]
+    neighbors = temp.copy()
+
+    for val in temp:
+        if val[0] < left or val[0] >= right:
+            neighbors.remove(val)
+        elif val[1] < top or val[1] >= bottom:
+            neighbors.remove(val)
+
+    return neighbors
+
+
+# External use ok
+def construct_nx_graph(xv, yv, elevation, triangles=False, p=2, scale=False):
+    
+    n = elevation.shape[0]
+    m = elevation.shape[1]
+    counts = np.reshape(np.arange(0, n*m), (n, m))
+    G = nx.Graph()
+
+    node_features = []
+    #fig = plt.figure()
+    #ax = fig.add_subplot(projection='3d')
+    for i in range(0, n):
+        for j in range(0, m):
+            idx1 = counts[i, j]
+            G.add_node(idx1)
+            node_features.append(np.array([xv[i, j], yv[i, j], elevation[i, j]]))
+            neighbors = get_array_neighbors_(i, j, right=elevation.shape[0], bottom=elevation.shape[1], radius=1)
+            for neighbor in neighbors:
+                p1 = np.array([xv[i, j], yv[i, j], elevation[i, j]])
+
+                p2 = np.array([xv[neighbor[0], neighbor[1]], yv[neighbor[0], neighbor[1]], elevation[neighbor[0], neighbor[1]]])
+                if scale:
+                    slope = (abs(p1[2] - p2[2]))/(abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]))
+                    # w = np.log(1 + slope)
+                    deg_angle = np.arctan(slope) * (180/np.pi)
+                    w = np.power(deg_angle, 1.2)
+                else:
+                    w = np.linalg.norm(p1 - p2, ord=p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                idx2 = counts[neighbor[0], neighbor[1]]
+                G.add_edge(idx1, idx2, weight=w)
+    if triangles:
+        for i in range(0, n - 1):
+            for j in range(0, m - 1):
+                # index cell by top left coordinate
+                triangle_edge = [(counts[i, j], counts[i + 1, j + 1]), (counts[i + 1, j], counts[i, j + 1])]
+                edge = triangle_edge[np.random.choice(2)]
+                for edge in triangle_edge:
+                    p1 = node_features[edge[0]]
+                    p2 = node_features[edge[1]]
+                    if scale:
+                        slope = (abs(p1[2] - p2[2]))/(abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]))
+                        # w = np.log(1 + slope)
+                        deg_angle = np.arctan(slope) * (180/np.pi)
+                        w = np.power(deg_angle, 1.2)
+                    else:
+                        w = np.linalg.norm(p1 - p2, ord=p)
+                #ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='black')
+                    G.add_edge(edge[0], edge[1], weight=w)
+    #fig.savefig('../images/norway-250.png')
+    return G, node_features
+
+def get_patches_(xv, yv, dem_array, patch_size, overlap):
+    patches = []
+    patch_graphs = []
+    patch_features = []
+    for i in trange(0, dem_array.shape[0] , patch_size - overlap):
+        for j in range(0, dem_array.shape[1], patch_size- overlap):
+            xv_patch = xv[i:i + patch_size, j:j+patch_size]
+            yv_patch = yv[i:i+patch_size, j : j+patch_size]
+            patch = dem_array[i : i + patch_size, j : j + patch_size].copy()
+            graph, node_features = construct_nx_graph(xv_patch, yv_patch, patch)
+            # print(patch.shape)
+            # print(list(nx.selfloop_edges(graph)))
+            patches.append(patch)
+            patch_graphs.append(graph)
+            patch_features.append(node_features)
+
+    return patches, patch_graphs, patch_features
+
+def get_edge_index(G):
+    weights = []
+
+    edges = [[], []]
+
+    for e in G.edges(data=True):
+        edges[0].append(e[0])
+        edges[1].append(e[1])
+        edges[0].append(e[1])
+        edges[1].append(e[0])
+
+        weights.append(e[2]['weight'])
+        weights.append(e[2]['weight'])
+    return edges, weights
+
+def construct_patch_dataset(xv, yv, dem_array, patch_size, sz, triangles=False, scale=False):
+    all_data = []
+    print("size of dataset:", sz, "patch sizes:", patch_size)
+    n = dem_array.shape[0]
+    m = dem_array.shape[1]
+    nc = 40
+    cx = np.random.choice(n-patch_size, size=nc, replace=False)
+    cy = np.random.choice(m - patch_size, size=nc, replace=False)
+    for i in range(nc):
+        xr = cx[i]
+        yr = cy[i]
+        xv_patch = xv[xr: xr + patch_size, yr: yr+patch_size]
+        yv_patch = yv[xr: xr + patch_size, yr: yr+patch_size]
+        patch = dem_array[xr: xr + patch_size, yr: yr+patch_size]
+        graph, node_features = construct_nx_graph(xv_patch, 
+                                                  yv_patch, 
+                                                  patch, 
+                                                  triangles=triangles, 
+                                                  scale=scale)
+
+        edge_index, weights = get_edge_index(graph)
+        for m in trange(patch_size * patch_size):
+            for n in range(m + 1, patch_size * patch_size):
+                shortest_path = nx.shortest_path_length(graph, m, n, weight='weight')
+                data=TerrainPatchesData(x=node_features, 
+                                        edge_index = edge_index, 
+                                        edge_attr=weights, 
+                                        src=m, 
+                                        tar=n, 
+                                        length=shortest_path)
+                all_data.append(data)
+
+    # for i in trange(sz):
+    #     c = np.random.randint(low = 0, high=5)
+    #     #c = 0
+    #     xr = cx[c]
+    #     yr = cy[c]
+    #     xv_patch = xv[xr: xr + patch_size, yr: yr+patch_size]
+    #     yv_patch = yv[xr: xr + patch_size, yr: yr+patch_size]
+    #     patch = dem_array[xr: xr + patch_size, yr: yr+patch_size]
+    #     graph, node_features = construct_nx_graph(xv_patch, 
+    #                                               yv_patch, 
+    #                                               patch, 
+    #                                               triangles=triangles, 
+    #                                               scale=scale)
+
+    #     edge_index, weights = get_edge_index(graph)
+        
+    #     src, tar = np.random.choice(len(node_features), [2, ], replace=False)
+    #     if src == tar:
+    #         continue
+    #     shortest_path = nx.shortest_path_length(graph, src, tar, weight='weight')
+    #     data=TerrainPatchesData(x=node_features, 
+    #                             edge_index = edge_index, 
+    #                             edge_attr=weights, 
+    #                             src=src, 
+    #                             tar=tar, 
+    #                             length=shortest_path)
+    #     all_data.append(data)
+    return all_data, np.hstack((cx, cy))
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--name', type=str)
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str) # saves should be named `gr-{graph-resolution}-ps-{patch-size}-ol-{overlap}`
+    parser.add_argument('--graph-resolution', type=int)
+    parser.add_argument('--patch-size', type=int)
+    parser.add_argument('--dataset-size', type=int)
+    parser.add_argument('--triangles', action='store_true')
+    parser.add_argument('--scale', action='store_true')
+
+    args = parser.parse_args()
+
+    dem_res = DATASET_INFO[args.name][0]
+    imperial = DATASET_INFO[args.name][1]
+
+    if args.name == 'la':
+        dem_array = np.load(args.raw_data)
+    else:
+        dem_array = load_dem_data_(args.raw_data, imperial)
+
+    xv, yv, elevations = get_dem_xv_yv_(dem_array, dem_res)
+    print('total elevation shape:', elevations.shape)
+    xv = xv[::args.graph_resolution, :2000:args.graph_resolution]
+    yv = yv[::args.graph_resolution, :2000:args.graph_resolution]
+    elevations = elevations[::args.graph_resolution, :2000:args.graph_resolution]
+    print("DEM array shape", elevations.shape)
+
+    all_data, centers = construct_patch_dataset(xv, 
+                                                yv, 
+                                                elevations, 
+                                                args.patch_size, 
+                                                args.dataset_size,
+                                                triangles=args.triangles, 
+                                                scale=args.scale)
+    torch.save(all_data, args.filename+'.pt')
+    torch.save(centers, args.filename + '-centers.pt')
+
+if __name__ == '__main__':
+    main()

server-local/shortest-paths-terrain-patches/dataset/point_sampler.py

@@ -0,0 +1,59 @@
+# From Haoyun Wang: I took this chunk of code from Haoyun Wang's final project 
+# from the Topological Data Analysis course from UCSD.
+
+import numpy as np
+import torch
+import networkx as nx
+from ripser import ripser, lower_star_img
+from persim import plot_diagrams
+
+def random_sampling(graph: nx.Graph, samples_per_source, src=None):
+    if src is None:
+        src = np.random.randint(0, graph.number_of_nodes())
+    distance = nx.single_source_dijkstra_path_length(graph, src)
+    # random
+    target = np.random.choice(graph.number_of_nodes(), (samples_per_source, ), replace=False)
+    distance = [distance[t] for t in target]
+    return [src] * samples_per_source, target.tolist(), distance
+
+
+def distance_based(graph: nx.Graph, samples_per_source, src=None):
+    if src is None:
+        src = np.random.randint(0, graph.number_of_nodes())
+    distance = nx.single_source_dijkstra_path_length(graph, src)
+    # random
+    vertices = np.arange(graph.number_of_nodes())
+    row_num = int(np.around(graph.number_of_nodes() ** 0.5))
+    hops = abs(src // row_num - vertices // row_num) + abs(src % row_num - vertices % row_num) + 1
+    probs = 1 / hops
+    probs = probs / probs.sum()
+    target = np.random.choice(vertices, (samples_per_source, ), p=probs, replace=False)
+    distance = [distance[t] for t in target]
+    return [src] * samples_per_source, target.tolist(), distance
+
+
+def find_critical_points(terrain, threshold):
+    # the original terrain has same-height points we must break the tie
+    N = terrain.shape[0]
+    terrain[:, :, 2] += torch.rand((N, N)) * 1e-5
+    lower_dgm = lower_star_img(terrain[:, :, 2])
+    upper_dgm = - lower_star_img(- terrain[:, :, 2])
+    long_pers_lower_dgm = lower_dgm[lower_dgm[:, 1]- lower_dgm[:, 0] > threshold]
+    long_pers_upper_dgm = upper_dgm[upper_dgm[:, 0]- upper_dgm[:, 1] > threshold]
+    long_pers_dgm = np.concatenate([long_pers_lower_dgm, long_pers_upper_dgm])
+    print(f"{long_pers_dgm.shape[0]} significant critical point pairs")
+
+    flatten_terrain = terrain.flatten(0, 1)
+    critical_idx_0 = [np.argmin(abs(flatten_terrain[:, 2] - long_pers_lower_dgm[i, 0])) for i in range(long_pers_lower_dgm.shape[0])]
+    critical_idx_2 = [np.argmin(abs(flatten_terrain[:, 2] - long_pers_upper_dgm[i, 0])) for i in range(long_pers_upper_dgm.shape[0])]
+    critical_idx_1 = [np.argmin(abs(flatten_terrain[:, 2] - long_pers_lower_dgm[i, 1])) for i in range(long_pers_lower_dgm.shape[0])] + \
+                    [np.argmin(abs(flatten_terrain[:, 2] - long_pers_upper_dgm[i, 1])) for i in range(long_pers_upper_dgm.shape[0])]
+    critical_idx_1 = list(set(critical_idx_1))
+
+    critical_idx = torch.stack(critical_idx_0 + critical_idx_1 + critical_idx_2)
+    # shuffle it
+    critical_idx = critical_idx[torch.randperm(critical_idx.shape[0])]
+    critical_idx = [src.item() for src in critical_idx]
+    return critical_idx
+
+        

server-local/shortest-paths-terrain-patches/dataset/py-to-wavefront.py

@@ -0,0 +1,76 @@
+import numpy as np
+import torch, queue
+from torch_geometric.data import Data
+import networkx as nx
+import matplotlib.pyplot as plt
+from tqdm import tqdm, trange
+import multiprocessing as mp
+import time
+import itertools
+
+import argparse
+
+from torch_geometric.utils import to_networkx
+
+def npz_to_dataset(data):
+    
+    edge_index = torch.tensor(data['edge_index'], dtype=torch.long)
+
+    srcs = data['srcs']
+    tars = data['tars']
+    lengths = data['lengths']
+    node_features = torch.tensor(data['node_features'], dtype=torch.double)
+
+    return srcs, tars, lengths, node_features, edge_index
+
+def triangle_graph_to_wavefront_obj(vertices, edge_index, n, m, filename, triangle=False):
+    f = open(filename, "w")
+
+    ids = np.reshape(np.arange(1, n * m  + 1), (n, m))
+
+    for v in vertices:
+        string = f'v {v[0]} {v[1]} {v[2]}\n'
+        f.write(string)
+    graph_data = Data(x =vertices, edge_index = edge_index)
+    G = to_networkx(graph_data)
+    
+    for i in range(n - 1):
+        for j in range(m - 1):
+            # cell_idx = ids[i, j]
+            if triangle:
+                if G.has_edge(ids[i, j + 1], ids[i + 1, j]):
+                    # diagonal = (ids[i, j + 1], ids[i + 1, j])
+                    f1 = f'f {ids[i, j]} {ids[i + 1, j]} {ids[i, j + 1]} \n'
+                    f2 = f'f {ids[i, j + 1]} {ids[i + 1, j]} {ids[i + 1, j + 1]}\n'
+                    f.write(f1)
+                    f.write(f2)
+                else:
+                    # diagonal = (ids[i, j], ids[i + 1, j + 1])
+                    f1 = f'f {ids[i, j]} {ids[i + 1, j + 1]} {ids[i, j + 1]}\n'
+                    f2 = f'f {ids[i, j]} {ids[i + 1, j]} {ids[i + 1, j + 1]} \n'
+                    f.write(f1)
+                    f.write(f2)
+            else:
+                face = f'f {ids[i, j]}  {ids[i + 1, j]} {ids[i + 1, j + 1]} {ids[i, j + 1]} \n'
+                f.write(face)
+            
+    f.close()
+    print("Saved wavefront obj to:", filename)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--raw-data', type=str)
+    parser.add_argument('--filename', type=str)
+    parser.add_argument('--n', type=int)
+    parser.add_argument('--m', type=int)
+    parser.add_argument('--triangle', action='store_true')
+
+    args = parser.parse_args()
+
+    data = np.load(args.raw_data, allow_pickle=True)
+    _, _, _, vertices, edge_index = npz_to_dataset(data)
+    print(len(vertices))
+    triangle_graph_to_wavefront_obj(vertices, edge_index, args.n, args.m, args.filename, triangle=args.triangle)
+
+if __name__ =='__main__':
+    main()