def test_convex_hull(self): # Smoke test fig = plt.figure() tri = ConvexHull(self.points) r = convex_hull_plot_2d(tri, ax=fig.gca()) assert_(r is fig) convex_hull_plot_2d(tri)
def test_convex_hull(self): # Smoke test fig = plt.figure() tri = ConvexHull(self.points) with suppress_warnings() as sup: # filter can be removed when matplotlib 1.x is dropped sup.filter(message="The ishold function was deprecated in version") r = convex_hull_plot_2d(tri, ax=fig.gca()) assert_(r is fig) convex_hull_plot_2d(tri)
def GetConvexHullVertices(lst_x,lst_y, show_plt = True): a = np.array(lst_x) b = np.array(lst_y) points = np.column_stack((a, b)) hull = ConvexHull(points) if show_plt: figure = convex_hull_plot_2d(hull) plt.suptitle("convexhull") plt.show() return hull.vertices # indices of the convex hull vertices
def plot_search(results, N_data, N_queries, axlims=None): ts = results["ts"] ndcgs = results["ndcgs"] x = ts.flatten() y = ndcgs.flatten() optX, optY, idxs = pareto_frontier(x, y, maxX = False) b = results['bs_rep'].flatten() e = results['es_rep'].flatten() M = results['Ms_rep'].flatten() L = results['Ls_rep'].flatten() print("Optimal points") print("{:>3},{:>4},{:>3},{:>3},{:>5},{:>6}".format( "b","e","M","L","t","ndcg")) for i, idx in enumerate(idxs): print("{:3.0f},{:4.1f},{:3.0f},{:3.0f},{:5.2f},{:6.3f}".format( b[idx], e[idx], M[idx], L[idx], optX[i], optY[i])) x = np.append(x, 100) x = np.append(0, x) y = np.append(y, 1) y = np.append(0, y) pts = np.vstack((x,y)).T hull = ConvexHull(pts) convex_hull_plot_2d(hull) # plt.plot(optX, optY, '-b') # plt.plot(x, y, '.b') plt.xlabel('Time (msec/query)') plt.ylabel('NDCG') # plt.title('Dataset Size N = {}'.format(N_data, N_queries)) if axlims: plt.axis(axlims) plt.tight_layout() plt.savefig("op_{}-{}".format(N_data, N_queries), dpi=300) plt.show() return idxs
def zonotope_2d_plot(vertices, design=None, y=None, f=None, out_label=None, opts=None): """A utility for plotting (m,2) zonotopes with designs and quadrature rules. Parameters ---------- vertices : ndarray M-by-2 matrix that contains the vertices that define the zonotope design : ndarray, optional N-by-2 matrix that contains a design-of-experiments on the zonotope. The plot will contain the Delaunay triangulation of the points in `design` and `vertices`. (default None) y : ndarray, optional K-by-2 matrix that contains points to be plotted inside the zonotope. If `y` is given, then `f` must be given, too. (default None) f: ndarray, optional K-by-1 matrix that contains a color value for the associated points in `y`. This is useful for plotting function values or quadrature rules with the zonotope. If `f` is given, then `y` must be given, too. (default None) out_label : str, optional a label for the quantity of interest (default None) opts : dict, optional a dictionary with some plot options (default None) Notes ----- This function makes use of the scipy.spatial routines for plotting the zonotopes. """ if opts == None: opts = plot_opts() # set labels for plots if out_label is None: out_label = 'Output' if vertices.shape[1] != 2: raise Exception('Zonotope vertices should be 2d.') if design is not None: if design.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if y is not None: if y.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if (y is not None and f is None) or (y is None and f is not None): raise Exception('You need both y and f to plot.') if y is not None and f is not None: if y.shape[0] != f.shape[0]: raise Exception('Lengths of y and f are not the same.') # get the xlim and ylim xmin, xmax = np.amin(vertices), np.amax(vertices) # make the Polygon patch for the zonotope ch = ConvexHull(vertices) # make the Delaunay triangulation if design is not None: points = np.vstack((design, vertices)) dtri = Delaunay(points) fig = plt.figure(figsize=(7, 7)) ax = fig.add_subplot(111) fig0 = convex_hull_plot_2d(ch, ax=ax) for l in fig0.axes[0].get_children(): if type(l) is Line2D: l.set_linewidth(3) if design is not None: fig1 = delaunay_plot_2d(dtri, ax=ax) for l in fig1.axes[0].get_children(): if type(l) is Line2D: et_color('0.75') if y is not None: plt.scatter(y[:, 0], y[:, 1], c=f, s=100.0, vmin=np.min(f), vmax=np.max(f)) plt.axes().set_aspect('equal') plt.title(out_label) plt.colorbar() plt.axis([1.1 * xmin, 1.1 * xmax, 1.1 * xmin, 1.1 * xmax]) plt.xlabel('Active variable 1') plt.ylabel('Active variable 2') show_plot(plt) if opts['savefigs']: figname = 'figs/zonotope_2d_' + out_label + opts['figtype'] plt.savefig(figname, dpi=300, bbox_inches='tight', pad_inches=0.0)
def generate_convex_hull(img, vis=False): rows, cols, _ = img.shape for i in range(rows): for j in range(cols): if(img[i,j,0] != 14): img[i,j,0] = 0 else: img[i,j,0] = 1 # view = img[:,:,0] # view[view != 14] = 1 # view[view == 14] = 0 kernel = np.ones((3,3), np.uint8) crosswalk = np.copy(img[:,:,0]) if vis == True: plt.figure(0) plt.imshow(crosswalk) crosswalk = cv2.erode(crosswalk, kernel, iterations=1) if vis == True: plt.figure(1) plt.imshow(crosswalk) crosswalks = connected_component(crosswalk, 1) if vis == True: plt.figure(2) plt.imshow(crosswalks) select_index = 11 chosen_crosswalk = np.copy(crosswalks) crosswalk_pts = np.zeros((1,2)) for i in range(rows): for j in range(cols): if(chosen_crosswalk[i,j] == select_index): crosswalk_pts = np.vstack((crosswalk_pts, np.array([i, j]))) else: chosen_crosswalk[i,j] = 9 crosswalk_pts = crosswalk_pts[1:, :] crosswalk_pts = np.fliplr(crosswalk_pts) hull = ConvexHull(points=crosswalk_pts, qhull_options='Q64') nodes = np.hstack((hull.vertices, hull.vertices[0])) vertices = crosswalk_pts[nodes, :] x_vertices = vertices[:, 0] y_vertices = vertices[:, 1] if vis == True: plt.figure(3) plt.imshow(chosen_crosswalk) fig = plt.figure(4) ax = fig.add_subplot(1,1,1) convex_hull_plot_2d(hull, ax=ax) plt.figure(5) plt.imshow(img[:,:,0]) plt.scatter(x_vertices, y_vertices, s=50, c='red', marker='o') plt.plot(x_vertices, y_vertices, c='red') plt.show() return vertices.T
kmeans.fit(X_train) y_kmeans = kmeans.predict(X_train) # cluster index for each observation centers = kmeans.cluster_centers_ # cluster center coordinates fig, ax = plt.subplots() plt.scatter(X_train[:, 0], X_train[:, 1], c=y_kmeans, s=5, cmap='summer') plt.scatter(centers[:, 0], centers[:, 1], c='black', s=100, alpha=0.5) from scipy.spatial import Voronoi, voronoi_plot_2d from scipy.spatial import ConvexHull, convex_hull_plot_2d db = DBSCAN(eps=0.5, min_samples=10).fit(X_train) core_samples_mask = np.zeros_like(db.labels_, dtype=bool) core_samples_mask[db.core_sample_indices_] = True y_db = DBSCAN(eps=0.5, min_samples=10).fit_predict(X_train) plt.scatter(X_train[:, 0], X_train[:, 1], c=y_db, cmap='summer') vor = Voronoi(centers) voronoi_plot_2d(vor, ax) # plt.scatter(X_train[:, 0], X_train[:, 1], c=y_kmeans, s=5, cmap='summer') # plt.show() for label in range(n_clusters): points = [X_train[index] for index in np.where(db.labels_ == label)[0]] hull = ConvexHull(points) convex_hull_plot_2d(hull, ax) plt.xlim((xmin, xmax)) plt.ylim((ymin, ymax)) plt.show()
p = points[s].mean(axis=0) plt.text(p[0], p[1], '#%d' % j, ha='center') # label triangles #plt.xlim(-0.5, 1.5); plt.ylim(-0.5, 1.5) plt.show() # Convex hulls from scipy.spatial import ConvexHull, convex_hull_plot_2d points = np.random.rand(30, 2) hull = ConvexHull(points) plt.plot(points[:, 0], points[:, 1], 'o') for simplex in hull.simplices: plt.plot(points[simplex, 0], points[simplex, 1], 'k-') plt.show() convex_hull_plot_2d(hull) # ----------------------------------------------------------------------------- # STATS from scipy import stats help(stats) # Random variables from scipy.stats import norm # normal # from __future__ import print_function print(stats.norm.__doc__)
def zonotope_2d_plot(vertices, design=None, y=None, f=None, out_label=None, opts=None): if opts == None: opts = plot_opts() # set labels for plots if out_label is None: out_label = 'Output' if vertices.shape[1] != 2: raise Exception('Zonotope vertices should be 2d.') if design is not None: if design.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if y is not None: if y.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if (y is not None and f is None) or (y is None and f is not None): raise Exception('You need both y and f to plot.') if y is not None and f is not None: if y.shape[0] != f.shape[0]: raise Exception('Lengths of y and f are not the same.') # get the xlim and ylim xmin, xmax = np.amin(vertices), np.amax(vertices) # make the Polygon patch for the zonotope ch = ConvexHull(vertices) # make the Delaunay triangulation if design is not None: points = np.vstack((design, vertices)) dtri = Delaunay(points) fig = plt.figure(figsize=(7,7)) ax = fig.add_subplot(111) convex_hull_plot_2d(ch, ax=ax) if design is not None: fig = delaunay_plot_2d(dtri, ax=ax) for l in fig.axes[0].get_children(): if type(l) is Line2D: l.set_color('0.75') if y is not None: plt.scatter(y[:,0], y[:,1], c=f, s=100.0, vmin=np.min(f), vmax=np.max(f)) plt.axes().set_aspect('equal') plt.title(out_label) plt.colorbar() plt.axis([1.1*xmin,1.1*xmax,1.1*xmin,1.1*xmax]) plt.xlabel('Active variable 1') plt.ylabel('Active variable 2') plt.show() if opts['savefigs']: figname = 'figs/zonotope_2d_' + out_label + opts['figtype'] plt.savefig(figname, dpi=300, bbox_inches='tight', pad_inches=0.0)
def main(): #G, pos = generate_graph() G = nx.read_gpickle("../data/graphs/public_toilet2.gpickle") print(G.number_of_nodes()) graph_sampler = GraphSampler() G = graph_sampler.down_sampler(G, 2000, 2000) G = nx.relabel.convert_node_labels_to_integers(G) pos = nx.get_node_attributes(G, 'pos') pos_list = list(map(list, list(pos.values()))) nx.draw(G, pos, node_size=30, with_labels=True) # Construct Voronoi diagram from nodes vor = Voronoi(pos_list) voronoi_plot_2d(vor) #hull = concaveHull(np.array(pos_list), k=3) #hull = np.array(list(map(list, list(hull)))) #plt.plot(hull[:, 0], hull[:, 1]) # Calculate convex hull around graph hull = ConvexHull(pos_list) convex_hull_plot_2d(hull) # Select Voronoi points inside convex hull # TODO: use clockwise points instead of convex hull filt_vor_vertices = [] for vertex in vor.vertices: if point_inside_polygon(vertex[0], vertex[1], np.array(pos_list)[hull.vertices]): filt_vor_vertices.append(list(vertex)) plt.scatter(np.array(vor.vertices)[:, 0], np.array(vor.vertices)[:, 1], c='g', s=50) plt.scatter(np.array(filt_vor_vertices)[:, 0], np.array(filt_vor_vertices)[:, 1], c='r', s=50) # Determine edges associated with vertices edge_list = list(G.edges) start_time = time.time() vertices_associated_edges = [] for vertex in tqdm(filt_vor_vertices): vertex_associated_edges = [] for edge_idx, edge in enumerate(edge_list): #edge1_pos1 = list(G._node[edge[0]]['pos']) #edge1_pos2 = list(G._node[edge[1]]['pos']) edge1_pos1 = pos_list[edge[0]] #list(G._node[edge[0]]['pos']) edge1_pos2 = pos_list[edge[1]] line_of_sight = True for comp_edge_idx, comp_edge in enumerate(edge_list): if edge_idx != comp_edge_idx: #edge2_pos1 = list(G._node[comp_edge[0]]['pos']) #edge2_pos2 = list(G._node[comp_edge[1]]['pos']) edge2_pos1 = pos_list[ comp_edge[0]] # list(G._node[edge[0]]['pos']) edge2_pos2 = pos_list[comp_edge[1]] mid_pos = [(edge1_pos1[0] + edge1_pos2[0]) / 2, (edge1_pos1[1] + edge1_pos2[1]) / 2] #if intersect(edge1_pos1, vertex, edge2_pos1, edge2_pos2) and \ # intersect(edge1_pos2, vertex, edge2_pos1, edge2_pos2): if intersect(vertex, mid_pos, edge2_pos1, edge2_pos2): line_of_sight = False break if line_of_sight: vertex_associated_edges.append(edge_idx) vertices_associated_edges.append(vertex_associated_edges) print(time.time() - start_time) # Determine vertices associated with vertices vertices_associated_vertices = [] for vertex_idx, vertex in tqdm(enumerate(filt_vor_vertices)): vertex_associated_vertices = [] vertex_associated_vertices.append(vertex_idx) for comp_vertex_idx, comp_vertex in enumerate(filt_vor_vertices): if comp_vertex_idx != vertex_idx: line_of_sight = True for edge in edge_list: edge_pos1 = list(G._node[edge[0]]['pos']) edge_pos2 = list(G._node[edge[1]]['pos']) if intersect(vertex, comp_vertex, edge_pos1, edge_pos2): line_of_sight = False break if line_of_sight: vertex_associated_vertices.append(comp_vertex_idx) vertices_associated_vertices.append(vertex_associated_vertices) room_graph = to_graph(vertices_associated_vertices) rooms_vertices = list(connected_components(room_graph)) #print(rooms_vertices) #print(vertices_associated_edges) print(rooms_vertices) rooms_nodes = [] for room_vertices in tqdm(rooms_vertices): row_idx = np.array(list(room_vertices)) plt.plot( np.array(filt_vor_vertices)[row_idx, 0], np.array(filt_vor_vertices)[row_idx, 1]) room_nodes = [] for vertex in list(room_vertices): for edge in vertices_associated_edges[vertex]: room_nodes.append(edge_list[edge][0]) room_nodes.append(edge_list[edge][1]) rooms_nodes.append(list(set(room_nodes))) color = iter(cm.rainbow(np.linspace(0, 1, len(rooms_nodes)))) for room_nodes in tqdm(rooms_nodes): room_pos = [] c = next(color) for node in room_nodes: pos = G._node[node]['pos'] room_pos.append(pos) # TODO could be a problem #ConvexHull #center = tuple(map(operator.truediv, reduce(lambda x, y: map(operator.add, x, y), room_pos), [len(room_pos)] * 2)) #room_pos_sorted = np.array(sorted(room_pos, key=lambda coord: (-135 - math.degrees(math.atan2(*tuple(map(operator.sub, coord, center))[::-1]))) % 360)) #plt.fill(room_pos_sorted[:, 0], room_pos_sorted[:, 1], c=c, alpha=0.2) #hull = concaveHull(np.array(room_pos),3) #plt.fill(np.array(hull)[:, 0], np.array(hull)[:, 1], c=c, alpha=0.2) #plt.fill(np.array(hull)[:, 0], np.array(hull)[:, 1], c=c, alpha=0.2) # TODO use known edges print(room_pos) if len(room_pos) > 2: hull = ConvexHull(room_pos) plt.fill(np.array(room_pos)[hull.vertices, 0], np.array(room_pos)[hull.vertices, 1], c=c, alpha=0.2) #plt.fill(np.array(room_pos)[hull.vertices][0], np.array(room_pos)[hull.vertices][1], c=c, alpha=0.2) print(hull) #plt.fill #plt.fill(np.array(rooms_nodes[0])[0], np.array(rooms_nodes[0])[1]) print(rooms_nodes) '''for room_nodes in rooms_nodes: room_pos = [] for node in room_nodes: edge_pos1 = G._node[node[0]]['pos'] edge_pos2 = G._node[node[1]]['pos'] hull = ConvexHull(room)''' '''rooms = [[]] for idx, vertices_associated in enumerate(vertices_associated_vertices): print(str(idx) + '/' + str(len(vertices_associated_vertices))) print(rooms) for room in rooms: if vertices_associated[0] in room: room = room + vertices_associated else: rooms.append(vertices_associated) for room in rooms: room = list(set(room)) print(vertices_associated_vertices) print(len(rooms))''' #rooms = merge_associated_edges(vertices_associated_vertices, vertices_associated_edges) #print(len(rooms)) '''for vertex_idx, vertices_associated in enumerate(vertices_associated_vertices): room_edges = [] room_edges.extend(vertices_associated_edges[vertex_idx]) for vertex in vertices_associated: room_edges.extend(vertices_associated_edges[vertex]) for room_edges = list(set(room_edges))''' plt.show() print("done")
y = np.dot(X, W[:, 0]) asp.sufficient_summary(y, F) # Get the response surface design and plot its points. # In[3]: # Get a design on the active variable n = 2 # dimension of the active subspace N = [10] # number points in the active variable NMC = 10 # number of monte carlo samples XX, ind, Y = ac.response_surface_design(W, n, N, NMC, bflag=1) # look at the zonotope and the design zt = ac.Zonotope(W[:, :n]) convex_hull_plot_2d(zt.convhull) plt.plot(Y[:, 0], Y[:, 1], 'ro') plt.xlabel('Active variable 1') plt.ylabel('Active variable 2') plt.show() # In[4]: # sample the function at the design points FF = ac.sample_function(XX, fun, dflag=True)[0] # compute conditional expectations G, V = ac.conditional_expectations(FF, ind) # build the response surface on the active variable gp = ac.GaussianProcess(2)
def zonotope_2d_plot(vertices, design=None, y=None, f=None, out_label=None, opts=None): """ A utility for plotting (m,2) zonotopes with associated designs and quadrature rules. :param ndarray vertices: M-by-2 matrix that contains the vertices that define the zonotope. :param ndarray design: N-by-2 matrix that contains a design-of-experiments on the zonotope. The plot will contain the Delaunay triangulation of the points in `design` and `vertices`. :param ndarray y: K-by-2 matrix that contains points to be plotted inside the zonotope. If `y` is given, then `f` must be given, too. :param ndarray f: K-by-1 matrix that contains a color value for the associated points in `y`. This is useful for plotting function values or quadrature rules with the zonotope. If `f` is given, then `y` must be given, too. :param str out_label: A label for the quantity of interest. :param dict opts: A dictionary with some plot options. **Notes** This function makes use of the scipy.spatial routines for plotting the zonotopes. """ if opts == None: opts = plot_opts() # set labels for plots if out_label is None: out_label = 'Output' if vertices.shape[1] != 2: raise Exception('Zonotope vertices should be 2d.') if design is not None: if design.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if y is not None: if y.shape[1] != 2: raise Exception('Zonotope design should be 2d.') if (y is not None and f is None) or (y is None and f is not None): raise Exception('You need both y and f to plot.') if y is not None and f is not None: if y.shape[0] != f.shape[0]: raise Exception('Lengths of y and f are not the same.') # get the xlim and ylim xmin, xmax = np.amin(vertices), np.amax(vertices) # make the Polygon patch for the zonotope ch = ConvexHull(vertices) # make the Delaunay triangulation if design is not None: points = np.vstack((design, vertices)) dtri = Delaunay(points) fig = plt.figure(figsize=(7,7)) ax = fig.add_subplot(111) fig0 = convex_hull_plot_2d(ch, ax=ax) for l in fig0.axes[0].get_children(): if type(l) is Line2D: l.set_linewidth(3) if design is not None: fig1 = delaunay_plot_2d(dtri, ax=ax) for l in fig1.axes[0].get_children(): if type(l) is Line2D: l.set_color('0.75') if y is not None: plt.scatter(y[:,0], y[:,1], c=f, s=100.0, vmin=np.min(f), vmax=np.max(f)) plt.axes().set_aspect('equal') plt.title(out_label) plt.colorbar() plt.axis([1.1*xmin,1.1*xmax,1.1*xmin,1.1*xmax]) plt.xlabel('Active variable 1') plt.ylabel('Active variable 2') show_plot(plt) if opts['savefigs']: figname = 'figs/zonotope_2d_' + out_label + opts['figtype'] plt.savefig(figname, dpi=300, bbox_inches='tight', pad_inches=0.0)