def plot_2d_clusters(X, labels, centers): """ Given an observation array, a label vector, and the location of the centers plot the clusters """ clabels = set(labels) K = len(clabels) if len(centers) != K: raise ValueError("Expecting the number of unique labels and centres to" " be the same!") # Plot the true clusters figure(figsize=(10, 10)) ax = gca() vor = Voronoi(centers) voronoi_plot_2d(vor, ax) colors = cm.hsv(np.arange(K)/float(K)) for k, col in enumerate(colors): my_members = labels == k scatter(X[my_members, 0], X[my_members, 1], c=col, marker='o', s=20) for k, col in enumerate(colors): cluster_center = centers[k] scatter(cluster_center[0], cluster_center[1], c=col, marker='o', s=200) axis('tight') axis('equal') title('Clusters')
def plot_cs_voronoi_scipy(): """ CubeGridRemap.get_voronoi(): Plot with voronoi_plot_2d """ from cube_remap import CubeGridRemap from scipy.spatial import voronoi_plot_2d import matplotlib.pyplot as plt # ne, ngq = 30, 4 ne, ngq = 3, 4 rotated = False cube = CubeGridRemap(ne, ngq, rotated) print "ne=%d, ngq=%d" % (ne, ngq) for uid in xrange(20): xy_vertices, vor = cube.get_voronoi(uid) print "" print "uid", uid print "vor.vertices\n", vor.vertices print "vor.ridge_points\n", vor.ridge_points print "vor.ridge_vertices\n", vor.ridge_vertices print "" print "xy_vertices\n", xy_vertices voronoi_plot_2d(vor) # plt.savefig('voronoi_%d.png'%uid) plt.show()
def test_BorderBuilder(self): plt.clf() polygon = self.generatePolygon(0, 0, 5, 0.1, 0.1, 50) polygon.append(polygon[0]) x, y = zip(*polygon) # plt.plot(x, y) x, y = self._addRandomPoints(x, y, 10) points = zip(x, y) vor = Voronoi(points) voronoi_plot_2d(vor) # plt.show() labels = map(int, mplPath.Path(polygon).contains_points(points)) waterX, waterY, insideX, insideY = [], [], [], [] for i in range(len(x)): if labels[i]: insideX.append(x[i]) insideY.append(y[i]) else: waterX.append(x[i]) waterY.append(y[i]) # plt.scatter(insideX, insideY, c="g") # plt.scatter(waterX, waterY, c="b") # plt.show() borders = self.TestBorderBuilder(x, y, labels).build() region = borders[0] for section in region: section.append(section[0]) x, y = zip(*section) plt.plot(x, y) plt.show()
def nn_vor(self): coords = self.atom_coords() vor = Voronoi(coords) print(vor.vertices) print(vor.regions) voronoi_plot_2d(vor) plt.show()
def plot_cs_voronoi(): ''' CubeGridRemap.get_voronoi(): Plot ''' from cube_remap import CubeGridRemap from scipy.spatial import voronoi_plot_2d import matplotlib.pyplot as plt #ne, ngq = 30, 4 ne, ngq = 3, 4 rotated = False cube = CubeGridRemap(ne, ngq, rotated) print 'ne=%d, ngq=%d'%(ne, ngq) for uid in xrange(20): xy_vertices, vor = cube.get_voronoi(uid) print '' print 'uid', uid print 'vor.vertices\n', vor.vertices print 'vor.ridge_points\n', vor.ridge_points print 'vor.ridge_vertices\n', vor.ridge_vertices print '' print 'xy_vertices\n', xy_vertices voronoi_plot_2d(vor) #plt.savefig('voronoi_%d.png'%uid) plt.show()
def main(): lati = coordGrab('Latitude') longi = coordGrab('Longitude') ''' map = Basemap(projection='merc', lat_0 = 57, lon_0 = -135, resolution = 'h', area_thresh = 0.1, llcrnrlon=-74.359150, llcrnrlat=40.530479, urcrnrlon=-73.585905, urcrnrlat=40.983567)''' points = zip(lati,longi) vor = Voronoi(points) voronoi_plot_2d(vor) ''' x,y = map(longi, lati) map.plot(x, y, 'bo', markersize=7, alpha=.7) map.drawcoastlines() map.drawcountries() map.drawcounties() map.fillcontinents(color = 'red') map.drawmapboundary() ''' plt.title("Location of CUNY campuses in NY") plt.show()
def test_voronoi(self): # Smoke test fig = plt.figure() obj = Voronoi(self.points) r = voronoi_plot_2d(obj, ax=fig.gca()) assert_(r is fig) voronoi_plot_2d(obj)
def voronoi(dataName,dataType,value): v_arr=genfromtxt(dataName + str(value) + dataType,delimiter=',' ) data = [[row[0],row[1]] for row in v_arr] vor = Voronoi(data) voronoi_plot_2d(vor) plt.xlim(300,700);plt.ylim(300,700); plt.savefig('voronoi_' + str(value) + '.png',dpi=200) print 'Saved Voronoi @ t=' + str(value)
def __init__(self, seed=0): if seed: np.random.seed(seed) self.beach = 0 self.index = [] self.coords = random_numbers() self.vor = Voronoi(self.coords) voronoi_plot_2d(self.vor)
def greeting(board): print "Hello, and welcome to gravitational voronoi!" print "currently the board looks like this." points = np.array(board) vor = Voronoi(points) voronoi_plot_2d(vor) plt.show() return points
def test_voronoi(self): # Smoke test fig = plt.figure() obj = Voronoi(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 = voronoi_plot_2d(obj, ax=fig.gca()) assert_(r is fig) voronoi_plot_2d(obj) voronoi_plot_2d(obj, show_vertices=False)
def player1(points,p1_stones_placed): x = int(raw_input("Please enter the x-coordinate for your move")) y = int(raw_input("Please enter the y-coordinate for your move")) vor = Voronoi(points,incremental=True) #needed or you can't add points move = np.array([[x,y]]) vor.add_points(move) print "You're new move looks like this:" voronoi_plot_2d(vor) plt.show() p1_stones_placed += 1 return move, p1_stones_placed
def plotting(DIR, z_name, opos): colours = ['#313695', '#4575b4', '#74add1',\ '#abd9e9', '#fdae61', '#f46d43', '#d73027', '#a50026',\ '#313695', '#4575b4', '#74add1',\ '#abd9e9', '#fdae61', '#f46d43', '#d73027', '#a50026',\ '#313695', '#4575b4', '#74add1',\ '#abd9e9', '#fdae61', '#f46d43', '#d73027', '#a50026'] xlo, xhi, ylo, yhi, zlo, zhi = coords(DIR, z_name) vor = Voronoi(opos) fig = voronoi_plot_2d(vor, show_vertices=False, point_size=0.1) # add colours for region in vor.regions: if not -1 in region: polygon = [vor.vertices[i] for i in region] plt.fill(*zip(*polygon), c=colours[2*len(region)+1]) #plt.fill plt.xlim(0, xhi) plt.ylim(ylo, yhi) plt.xlabel('$x$ (\AA)') plt.ylabel('$y$ (\AA)') plt.savefig('PLOTS_C/{}/voronoi_2d_{}.pdf'.format(DIR,z_name), bbox_inches='tight') #plt.show() return
def _tri_demo(tri_type='Delaunay'): """Triangulation demo. """ from scipy.spatial import delaunay_plot_2d, voronoi_plot_2d import matplotlib.pyplot as plt xs =[ 48, 8, 623, 615, 196, 368, 112, 918, 318, 316, 427, 364, 849, 827, 438, 957, 495, 317, 985, 534] ys = [674, 215, 834, 235, 748, 630, 876, 407, 33, 872, 893, 360, 397, 902, 420, 430, 678, 523, 604, 292] aa = np.array(list(zip(xs, ys))) c = infinity_circle(aa, fac=0) a = np.vstack((aa, c)) d = v = None # initialize the output to None if tri_type == 'Delaunay': d = Delaunay(aa) plot = delaunay_plot_2d(d) x0, y0 = [0., 0.] x1, y1 = [1000., 1000.] else: c = infinity_circle(a, fac=2) # a = np.vstack((a, c)) x0, y0 = a.min(axis=0) x1, y1 = a.max(axis=0) v = Voronoi(a, qhull_options='Qbb Qc Qx') plot = voronoi_plot_2d(v, show_vertices=True, line_colors='y', line_alpha=0.8, point_size=5) # ---- plot.set_figheight(10) plot.set_figwidth(10) plt.axis([0, 1000, 0, 1000]) # plt.axis([x0, x1, y0, y1]) plt.show() return aa, (d or v)
def Vor_pnts(pnts, testing=True, plot=True): """Requires a set of points deemed to be a cluster to delineate as a Voronoi diagram. You can do multiple point groupings by using this within a loop to return the geometries. """ avg = np.mean(pnts, axis=0) p = pnts - avg tri = Voronoi(p) out = [] for region in tri.regions: if not -1 in region: polygon = np.array([tri.vertices[i] + avg for i in region]) out.append(polygon) if testing: print("{}".format(polygon.T)) if plot: voronoi_plot_2d(tri) return out
def model2mesh(coord):#,stp,tolerance,lng): #This function performs a medial axis transform to a non-branching axis #Takes the outline coordinates, step size on the final centerline, #tolerance to non-centrality, and the length of the ribs. The last #parameter should be longer than the ribs, but should not be too long to #intersect the countour agan: though most cases of >1 intersection will #be resolved by the function, some will not. Outputs the coordinates of #the centerline points. delta = 1E-10; #voronoi transform vor = Voronoi(coords) print vor.vertices print type(vor.vertices) print dir(vor.vertices) print len(vor.vertices) voronoi_plot_2d(vor) plt.show() # % remove vertices crossing the boundary # vx = reshape(vx,[],1); # vy = reshape(vy,[],1); # q = intxy2(vx,vy,coord([1:end 1],1),coord([1:end 1],2)); # vx = reshape(vx(~[q;q]),2,[]); # vy = reshape(vy(~[q;q]),2,[]); # % remove vertices outside [of the cell?] # q = logical(inpolygon(vx(1,:),vy(1,:),coord(:,1),coord(:,2))... # .* inpolygon(vx(2,:),vy(2,:),coord(:,1),coord(:,2))); # vx = reshape(vx([q;q]),2,[]); # vy = reshape(vy([q;q]),2,[]); # % remove isolated points # if isempty(vx), res=0;return; end # t = ~((abs(vx(1,:)-vx(2,:))<delta)&(abs(vy(1,:)-vy(2,:))<delta)); # vx = reshape(vx([t;t]),2,[]); # vy = reshape(vy([t;t]),2,[]); #remove branches vx2=[]; vy2=[];
def doSom(): conn = pymongo_utill.getConnectionToMongoDB() db = conn['TwitterInsert'] #users,labels,screen_names = pymongo_utill.byTimeFreq(db=db,sample=225) users,labels,screen_names = pymongo_utill.byTimeFreq(db=db,sample=10) conn.disconnect() #vectorizer = WordVectorizer() #users = vectorizer.fit_transform(users) clusterid, celldata = somcluster(data=users, nxgrid=21, nygrid=31, niter=500) plt.xlim((-5,25)) plt.ylim((-5,35)) """ print(len(clusterid)) for i,v in enumerate(clusterid): print("number:%s coordinates:%s name:%s class:%s" % (i, v, screen_names[i], labels[i])) for i, (x,y) in enumerate(clusterid): if labels[i] == 0: plt.plot(x,y,'-bo') if labels[i] == 1: plt.plot(x,y,'-ro') plt.show() for i, v in enumerate(clusterid): plt.annotate(xy=v, s=int(i/7)) """ vor = Voronoi(clusterid) voronoi_plot_2d(vor) for region in vor.regions: if not -1 in region: polygon = [vor.vertices[i] for i in region] plt.fill(*zip(*polygon)) plt.show()
def plot(self): import matplotlib.pyplot as plt from scipy.spatial import Voronoi, voronoi_plot_2d # print "self.X:" # print self.X # print "self.size:" # print self.size fig = plt.figure(figsize=(10,8), dpi=96) ax = fig.add_subplot(111) # self.fig, self.ax = plt.subplots(1, 1) # self.fig.set_size_inches(10, 8) vor = Voronoi(self.mu) vor_plot = voronoi_plot_2d(vor, ax=ax) # remove the markers for each cluster and for the vertices ax.get_lines()[1].remove() #ax.get_lines()[0].remove() ax.scatter(x=self.X[:,0], y=self.X[:,1], c=self.cluster_id, s=self.size, alpha=0.75) ax.set_xlim(min(self.X[:,0]), max(self.X[:,0])) ax.set_ylim(min(self.X[:,1]), max(self.X[:,1])) # canvas.draw() # may not be needed? see http://stackoverflow.com/questions/26783843/redrawing-a-plot-in-ipython-matplotlib
def _imshow_grid_values(grid, values, var_name=None, var_units=None, grid_units=(None, None), symmetric_cbar=False, cmap='jet', limits=None, allow_colorbar=True): gridtypes = inspect.getmro(grid.__class__) if RasterModelGrid in gridtypes: if len(values.shape) != 2: raise ValueError('dimension of values must be 2 (%s)' % values.shape) y = np.arange(values.shape[0] + 1) - grid.dx * .5 x = np.arange(values.shape[1] + 1) - grid.dx * .5 kwds = dict(cmap=cmap) if limits is None: if symmetric_cbar: (var_min, var_max) = (values.min(), values.max()) limit = max(abs(var_min), abs(var_max)) (kwds['vmin'], kwds['vmax']) = (- limit, limit) else: (kwds['vmin'], kwds['vmax']) = (limits[0], limits[1]) myimage = plt.pcolormesh(x, y, values, **kwds) plt.gca().set_aspect(1.) plt.autoscale(tight=True) if allow_colorbar: plt.colorbar() plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if var_name is not None: plt.title('%s (%s)' % (var_name, var_units)) #plt.show() elif VoronoiDelaunayGrid in gridtypes: """ This is still very much ad-hoc, and needs prettifying. We should save the modifications needed to plot color all the way to the diagram edge *into* the grid, for faster plotting. (see http://stackoverflow.com/questions/20515554/colorize-voronoi-diagram) (This technique is not implemented yet) """ from scipy.spatial import voronoi_plot_2d import matplotlib.colors as colors import matplotlib.cm as cmx cm = plt.get_cmap(cmap) if limits is None: if symmetric_cbar: (var_min, var_max) = (values.min(), values.max()) limit = max(abs(var_min), abs(var_max)) (vmin, vmax) = (- limit, limit) else: (vmin, vmax) = (values.min(), values.max()) else: (vmin, vmax) = (limits[0], limits[1]) cNorm = colors.Normalize(vmin,vmax) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) colorVal = scalarMap.to_rgba(values) myimage = voronoi_plot_2d(grid.vor) mycolors = (i for i in colorVal) for order in grid.vor.point_region: region = grid.vor.regions[order] colortouse = next(mycolors) if not -1 in region: polygon = [grid.vor.vertices[i] for i in region] #print "polygon:" #print polygon #print len(polygon) #print "colortouse:" #print next(colortouse) #print len(colortouse) plt.fill(*zip(*polygon),color=colortouse) #must be TOTALLY sure the ordering is right plt.gca().set_aspect(1.) #plt.autoscale(tight=True) plt.xlim((np.min(grid.node_x), np.max(grid.node_x))) plt.ylim((np.min(grid.node_y), np.max(grid.node_y))) scalarMap.set_array(values) plt.colorbar(scalarMap) plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if var_name is not None: plt.title('%s (%s)' % (var_name, var_units)) return myimage
plt.show() if False: x = np.random.randn(50) y = np.random.randn(50) cc = voronoi_plot(x, y, field_lim = [-2.5, 2.5, -2.5, 2.5]) import matplotlib.pyplot as plt fig = plt.figure(figsize = (15., 6.)) ax = fig.add_subplot(1, 2, 1) ax2 = fig.add_subplot(1, 2, 2) vd = spt.Voronoi(np.vstack((x, y)).T) spt.voronoi_plot_2d(vd, ax2) ax.set_xlim(-3., 3.) ax.set_ylim(-3., 3.) ax.axvline(x = -2.5, linestyle = 'dashed') ax.axvline(x = 2.5, linestyle = 'dashed') ax.axhline(y = -2.5, linestyle = 'dashed') ax.axhline(y = 2.5, linestyle = 'dashed') ax2.set_xlim(-3., 3.) ax2.set_ylim(-3., 3.) ax2.axvline(x = -2.5, linestyle = 'dashed') ax2.axvline(x = 2.5, linestyle = 'dashed') ax2.axhline(y = -2.5, linestyle = 'dashed') ax2.axhline(y = 2.5, linestyle = 'dashed') for icc in cc:
def _imshow_grid_values(grid, values, var_name=None, var_units=None, grid_units=(None, None), symmetric_cbar=False, cmap='pink', limits=None, allow_colorbar=True, vmin=None, vmax=None, norm=None, shrink=1., color_for_closed='black'): gridtypes = inspect.getmro(grid.__class__) cmap = plt.get_cmap(cmap) cmap.set_bad(color=color_for_closed) if RasterModelGrid in gridtypes: if len(values.shape) != 2: raise ValueError('dimension of values must be 2 (%s)' % values.shape) y = np.arange(values.shape[0] + 1) * grid.dx - grid.dx * .5 x = np.arange(values.shape[1] + 1) * grid.dx - grid.dx * .5 kwds = dict(cmap=cmap) (kwds['vmin'], kwds['vmax']) = (values.min(), values.max()) # ^default condition if (limits is None) and ((vmin is None) and (vmax is None)): if symmetric_cbar: (var_min, var_max) = (values.min(), values.max()) limit = max(abs(var_min), abs(var_max)) (kwds['vmin'], kwds['vmax']) = (- limit, limit) else: pass elif limits is not None: (kwds['vmin'], kwds['vmax']) = (limits[0], limits[1]) else: if vmin is not None: kwds['vmin'] = vmin if vmax is not None: kwds['vmax'] = vmax myimage = plt.pcolormesh(x, y, values, **kwds) plt.gca().set_aspect(1.) plt.autoscale(tight=True) if allow_colorbar: plt.colorbar(norm=norm, shrink=shrink) plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if var_name is not None: plt.title('%s (%s)' % (var_name, var_units)) #plt.show() elif VoronoiDelaunayGrid in gridtypes: # This is still very much ad-hoc, and needs prettifying. # We should save the modifications needed to plot color all the way # to the diagram edge *into* the grid, for faster plotting. # (see http://stackoverflow.com/questions/20515554/colorize-voronoi-diagram) # (This technique is not implemented yet) from scipy.spatial import voronoi_plot_2d import matplotlib.colors as colors import matplotlib.cm as cmx cm = plt.get_cmap(cmap) if limits is None: #only want to work with NOT CLOSED nodes open_nodes = grid.node_status!=4 if symmetric_cbar: (var_min, var_max) = (values.flat[open_nodes].min(), values.flat[open_nodes].max()) limit = max(abs(var_min), abs(var_max)) (vmin, vmax) = (- limit, limit) else: (vmin, vmax) = (values.flat[open_nodes].min(), values.flat[open_nodes].max()) else: (vmin, vmax) = (limits[0], limits[1]) cNorm = colors.Normalize(vmin,vmax) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) colorVal = scalarMap.to_rgba(values) myimage = voronoi_plot_2d(grid.vor) mycolors = (i for i in colorVal) for order in grid.vor.point_region: region = grid.vor.regions[order] colortouse = next(mycolors) if -1 not in region: polygon = [grid.vor.vertices[i] for i in region] plt.fill(*zip(*polygon),color=colortouse) #must be TOTALLY sure the ordering is right plt.gca().set_aspect(1.) #plt.autoscale(tight=True) plt.xlim((np.min(grid.node_x), np.max(grid.node_x))) plt.ylim((np.min(grid.node_y), np.max(grid.node_y))) scalarMap.set_array(values) plt.colorbar(scalarMap) plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if var_name is not None: plt.title('%s (%s)' % (var_name, var_units)) return myimage
indices = np.where(labeled_particles == num) x_pos = np.average(indices[1]) y_pos = np.average(indices[0]) centers.append((x_pos, y_pos)) return centers centers = centersParticle() # make up data points points = np.random.rand(15, 2) vor = Voronoi(points) # Plot it: voronoi_plot_2d(vor) plt.show() regions = vor.regions reg_coords = [] for region in regions: if not -1 in region and len(region) > 0: coords = vor.vertices[region] reg_coords.append(coords) import numba @numba.jit(nopython=True) def areaPolygon(vertices): area = 0
def voronoi_prune_region(nodes, alpha_cut, keep=0.05, draw=None): """ Takes as input a list of points First computes the concave hull and removes all points outside it. Then remove all those points completely contained. In other words, only return those which are on the boundary of the hull. """ nodes_list = list(nodes) log.info("Pruning %i nodes", len(nodes_list)) points = np.array([(x.lon, x.lat) for x in nodes_list], dtype=float) # get the concave hull around these points hull = get_concave_hull(points, alpha_cut) if not hull: log.warning("Concave hull is null, using convex!") hull = get_convex_hull(points) # buffer hull by about 5% for determining membership hull_distance_scale = math.sqrt(hull.area) buffered_hull = prep(hull.buffer(hull_distance_scale * 0.05)) hull_boundary = hull.boundary # Remove any outlier points around these nodes. # Mark the good nodes. nodes_in_hull = [] nodes_outside_hull = [] for point, node in itertools.izip(points, nodes_list): if buffered_hull.contains(Point(point)): nodes_in_hull.append(node) else: nodes_outside_hull.append(node) # We only care about interior points now. del nodes_list points = np.array([(x.lon, x.lat) for x in nodes_in_hull], dtype=float) log.info("After hull cleaning, %i nodes remain", len(points)) voronoi = Voronoi(points) edge_regions = set([]) # find all regions which have a vertex outside the hull prepped_hull = prep(hull) for region_idx, region in enumerate(voronoi.regions): exterior_region = False # keep a random collection of interior points if random.random() < keep: exterior_region = True else: for vtx_idx in region: # indicates an exterior region, we always keep these if vtx_idx == -1: exterior_region = True break else: point = Point(voronoi.vertices[vtx_idx]) if not prepped_hull.contains(point): exterior_region = True break # Keep 20% of points very close to the border if random.random() < 0.2 and ( point.distance(hull_boundary) < hull_distance_scale * 0.03): exterior_region = True break if exterior_region: edge_regions.add(region_idx) output = [] point_region_map = voronoi.point_region for node_idx, node in enumerate(nodes_in_hull): region_idx = point_region_map[node_idx] if region_idx in edge_regions: output.append(node) log.info("There are %i nodes after pruning", len(output)) if draw is not None: log.info("Drawing prune plot") fig = plt.figure(figsize=(20, 20)) voronoi_plot_2d(voronoi) plt.plot( [x.lon for x in output], [x.lat for x in output], 'x', color='red', hold=1) plt.plot( [x.lon for x in nodes_outside_hull], [x.lat for x in nodes_outside_hull], 'D', color='orange', hold=1) plt.gca().add_patch(PolygonPatch(hull, alpha=0.2)) plt.savefig(draw) del fig return output
import matplotlib.pyplot as plt from matplotlib.patches import Ellipse from scipy.spatial import Voronoi, voronoi_plot_2d from scipy.spatial import Delaunay, delaunay_plot_2d #%% Delaunay and Voronoi fig = plt.figure() ax = fig.add_subplot(111, aspect='equal') np.random.seed(3) x, y = np.mgrid[0:1:10j, 0:1:10j] x[:, 1::2] = x[:, 1::2] + 0.05 x.shape = (100, 1) y.shape = (100, 1) pts = np.hstack([x, y]) + 0.02*np.random.normal(size=(100, 2)) vor = Voronoi(pts) voronoi_plot_2d(vor, ax=ax) tri = Delaunay(pts) delaunay_plot_2d(tri, ax=ax) scal = 0.9 for triang in tri.simplices: A = triang[0] B = triang[1] C = triang[2] vertices = np.array([pts[A], pts[B], pts[C]]) centroid, semi_minor, semi_major, ang = steiner_inellipse(vertices) ellipse = Ellipse(centroid, 2*scal*semi_major, 2*scal*semi_minor, angle=ang, facecolor="red", alpha=0.4) ax.add_artist(ellipse) plt.show()
# Point process parameters lambda0 = 10 # intensity (ie mean density) of the Poisson process # Simulate a Poisson point process numbPoints = np.random.poisson(lambda0 * areaTotal) # Poisson number of points xx = xDelta * np.random.uniform(0, 1, numbPoints) + xMin # x coordinates of Poisson points yy = yDelta * np.random.uniform(0, 1, numbPoints) + yMin # y coordinates of Poisson points xxyy = np.stack((xx, yy), axis=1) #combine x and y coordinates ##Perform Voroin tesseslation using built-in function voronoiData = Voronoi(xxyy) vertexAll = voronoiData.vertices #retrieve x/y coordinates of all vertices cellAll = voronoiData.regions #may contain empty array/set ####START -- Plotting section -- START### #create voronoi diagram on the point pattern voronoi_plot_2d(voronoiData, show_points=False, show_vertices=False) #plot underlying point pattern (ie a realization of a Poisson point process) plt.scatter(xx, yy, edgecolor='b', facecolor='b') #number the points for ii in range(numbPoints): plt.text(xx[ii] + xDelta / 50, yy[ii] + yDelta / 50, ii) ####END -- Plotting section -- END###
def create_links_and_faces_from_voronoi_diagram(vor): """ From a Voronoi diagram object created by scipy.spatial.Voronoi(), builds and returns: 1. Arrays of link "from" and "to" nodes 2. Array of link IDs for each active link 3. Array containing with of each face Parameters ---------- vor : scipy.spatial.Voronoi Voronoi object initialized with the grid nodes. Returns ------- out : tuple of ndarrays - link_fromnode = "from" node for each link (len=num_links) - link_tonode = "to" node for each link (len=num_links) - active_links = link ID for each active link (len=num_active_links) - face_width = width of each face (len=num_active_links Examples -------- >>> import numpy as np >>> from landlab.grid import VoronoiDelaunayGrid >>> pts = np.array([[ 0., 0.],[ 1., 0.],[ 1.5, 0.87],[-0.5, 0.87],[ 0.5, 0.87],[ 0., 1.73],[ 1., 1.73]]) >>> from scipy.spatial import Voronoi >>> vor = Voronoi(pts) >>> [fr,to,al,fw] = VoronoiDelaunayGrid.create_links_and_faces_from_voronoi_diagram(vor) >>> fr array([0, 0, 0, 1, 1, 3, 3, 6, 6, 6, 4, 4]) >>> to array([3, 1, 4, 2, 4, 4, 5, 4, 2, 5, 2, 5]) >>> al array([ 2, 4, 5, 7, 10, 11]) >>> fw array([ 0.57669199, 0.57669199, 0.575973 , 0.57836419, 0.575973 , 0.57836419]) """ # Each Voronoi "ridge" corresponds to a link. The Voronoi object has an # attribute ridge_points that contains the IDs of the nodes on either # side (including ridges that have one of their endpoints undefined). # So, we set the number of links equal to the number of ridges. num_links = len(vor.ridge_points) # Create the arrays for link from and to nodes link_fromnode = -numpy.ones(num_links, dtype=int) link_tonode = -numpy.ones(num_links, dtype=int) # Ridges along the perimeter of the grid will have one of their # endpoints undefined. The endpoints of each ridge are contained in # vor.ridge_vertices, and an undefined vertex is flagged with -1. # Ridges with both vertices defined correspond to faces and active # links, while ridges with an undefined vertex correspond to inactive # links. So, to find the number of active links, we subtract from the # total number of links the number of occurrences of an undefined # vertex. num_active_links = num_links \ - numpy.count_nonzero(numpy.array(vor.ridge_vertices)==-1) # Create arrays for active links and width of faces (which are Voronoi # ridges). active_links = -numpy.ones(num_active_links, dtype=int) face_width = -numpy.ones(num_active_links) # Loop through the list of ridges. For each ridge, there is a link, and # its "from" and "to" nodes are the associated "points". In addition, if # the ridge endpoints are defined, we have a face and an active link, # so we add them to our arrays as well. j = 0 for i in range(num_links): link_fromnode[i] = vor.ridge_points[i,0] link_tonode[i] = vor.ridge_points[i,1] face_corner1 = vor.ridge_vertices[i][0] face_corner2 = vor.ridge_vertices[i][1] if VoronoiDelaunayGrid.is_valid_voronoi_ridge(vor, i): # means it's a valid face dx = vor.vertices[face_corner2,0]-vor.vertices[face_corner1,0] dy = vor.vertices[face_corner2,1]-vor.vertices[face_corner1,1] face_width[j] = numpy.sqrt(dx*dx+dy*dy) if abs(face_width[j])>=40000.0: six.print_('link ' + i + ' from ' + link_fromnode[i] + ' to ' + link_tonode[i] + ' has face width ' + face_width[j]) six.print_(vor.ridge_vertices[i]) six.print_(vor.vertices[vor.ridge_vertices[i]]) from scipy.spatial import voronoi_plot_2d voronoi_plot_2d(vor) assert face_width[j] < 40000., 'face width must be less than earth circumference!' active_links[j] = i j += 1 #save the data #self.node_at_link_tail = link_fromnode #self.node_at_link_head = link_tonode #self.active_link_ids = active_links #self._face_widths = face_width #self._num_faces = face_width.size #self._num_active_links = active_links.size return link_fromnode, link_tonode, active_links, face_width
points = np.random.rand(111, 2) print(points) for k in range(111): points[k][0]=output['lat'][k] points[k][1]=output['lon'][k] print(points) #points = np.random.rand(15, 2) #print points # compute Voronoi tesselation vor = Voronoi(points) print(vor) # plot regions, vertices = voronoi_plot_2d(vor) # print "--" # print regions # print "--" # print vertices # colorize for region in regions: polygon = vertices[region] plt.fill(*zip(*polygon), alpha=0.6) plt.plot(points[:,0], points[:,1], 'ko',markersize=2) plt.xlim(vor.min_bound[0] - 0.1, vor.max_bound[0] + 0.1) plt.ylim(vor.min_bound[1] - 0.1, vor.max_bound[1] + 0.1) plt.show()
def draw_kmeans_clusters(self, filename, figsize=(4,3)): import matplotlib as mpl mpl.use('Agg') import matplotlib.patches as mpatches import matplotlib.pyplot as plt from sklearn.cluster import KMeans from scipy.spatial import Voronoi, voronoi_plot_2d from mpl_toolkits.basemap import Basemap, cm, maskoceans #from matplotlib import style #import seaborn as sns #sns.set_style("white") #plt.rc('text', usetex=True) #plt.rc('font', family='serif') #plt.rcParams['axes.facecolor']='white' fig = plt.figure(figsize=figsize) lllat = 24.396308 lllon = -124.848974 urlat = 49.384358 urlon = -66.885444 m = Basemap(llcrnrlat=lllat, urcrnrlat=urlat, llcrnrlon=lllon, urcrnrlon=urlon, resolution='c', projection='cyl') m.drawmapboundary(fill_color = 'white') m.drawcoastlines(linewidth=0.2) m.drawcountries(linewidth=0.2) ax = plt.gca() ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) for spine in ax.spines.itervalues(): spine.set_visible(False) #fig = plt.figure() # figsize=(4,4.2) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) train_locs = self.df_train[['lat', 'lon']].values n_clusters = int(np.ceil(train_locs.shape[0] / self.bucket_size)) n_clusters = 128 logging.info('n_cluster %d' %n_clusters) clusterer = KMeans(n_clusters=n_clusters, n_jobs=10) clusterer.fit(train_locs) centroids = clusterer.cluster_centers_ centroids[:,[0, 1]] = centroids[:,[1, 0]] mlon, mlat = m(*(centroids[:,0], centroids[:,1])) centroids = np.transpose(np.vstack((mlon, mlat))) vor = Voronoi(centroids) #ax.set_xlim([-125, -60]) # pylab.xlim([-400, 400]) #ax.set_ylim([25, 50]) plt.setp(ax.get_yticklabels(), visible=False) plt.setp(ax.get_xticklabels(), visible=False) ax.yaxis.set_tick_params(size=0) ax.xaxis.set_tick_params(size=0) #plt.tick_params(axis='both', which='major', labelsize=25) #ax.labelsize = '25' #plt.subplots_adjust(bottom=0.2) voronoi_plot_2d(vor, show_points=False, show_vertices=False, ax=ax, line_width=0.7) m.drawlsmask(land_color='lightgray',ocean_color="#b0c4de", lakes=True) plt.tight_layout() plt.savefig(filename) #plt.close() print("the plot saved in " + filename)
def _imshow_grid_values(grid, values, plot_name=None, var_name=None, var_units=None, grid_units=(None, None), symmetric_cbar=False, cmap='pink', limits=None, colorbar_label = None, allow_colorbar=True, vmin=None, vmax=None, norm=None, shrink=1., color_for_closed='black', color_for_background=None, show_elements=False, output=None): gridtypes = inspect.getmro(grid.__class__) cmap = plt.get_cmap(cmap) if color_for_closed is not None: cmap.set_bad(color=color_for_closed) else: cmap.set_bad(alpha=0.) if isinstance(grid, RasterModelGrid): if values.ndim != 2: raise ValueError('values must have ndim == 2') y = np.arange(values.shape[0] + 1) * grid.dy - grid.dy * .5 x = np.arange(values.shape[1] + 1) * grid.dx - grid.dx * .5 kwds = dict(cmap=cmap) (kwds['vmin'], kwds['vmax']) = (values.min(), values.max()) if (limits is None) and ((vmin is None) and (vmax is None)): if symmetric_cbar: (var_min, var_max) = (values.min(), values.max()) limit = max(abs(var_min), abs(var_max)) (kwds['vmin'], kwds['vmax']) = (- limit, limit) elif limits is not None: (kwds['vmin'], kwds['vmax']) = (limits[0], limits[1]) else: if vmin is not None: kwds['vmin'] = vmin if vmax is not None: kwds['vmax'] = vmax if np.isclose(grid.dx, grid.dy): if values.size == grid.number_of_nodes: myimage = plt.imshow( values.reshape(grid.shape), origin='lower', extent=(x[0], x[-1], y[0], y[-1]), **kwds) else: # this is a cell grid, and has been reshaped already... myimage = plt.imshow(values, origin='lower', extent=(x[0], x[-1], y[0], y[-1]), **kwds) myimage = plt.pcolormesh(x, y, values, **kwds) plt.gca().set_aspect(1.) plt.autoscale(tight=True) if allow_colorbar: cb = plt.colorbar(norm=norm, shrink=shrink) if colorbar_label: cb.set_label(colorbar_label) elif VoronoiDelaunayGrid in gridtypes: # This is still very much ad-hoc, and needs prettifying. # We should save the modifications needed to plot color all the way # to the diagram edge *into* the grid, for faster plotting. # (see http://stackoverflow.com/questions/20515554/... # colorize-voronoi-diagram) # (This technique is not implemented yet) from scipy.spatial import voronoi_plot_2d import matplotlib.colors as colors import matplotlib.cm as cmx cm = plt.get_cmap(cmap) if (limits is None) and ((vmin is None) and (vmax is None)): # only want to work with NOT CLOSED nodes open_nodes = grid.status_at_node != 4 if symmetric_cbar: (var_min, var_max) = (values.flat[ open_nodes].min(), values.flat[open_nodes].max()) limit = max(abs(var_min), abs(var_max)) (vmin, vmax) = (- limit, limit) else: (vmin, vmax) = (values.flat[ open_nodes].min(), values.flat[open_nodes].max()) elif limits is not None: (vmin, vmax) = (limits[0], limits[1]) else: open_nodes = grid.status_at_node != 4 if vmin is None: vmin = values.flat[open_nodes].min() if vmax is None: vmax = values.flat[open_nodes].max() cNorm = colors.Normalize(vmin, vmax) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) colorVal = scalarMap.to_rgba(values) if show_elements: myimage = voronoi_plot_2d(grid.vor, show_vertices=False, show_points=False) # show_points to be supported in scipy0.18, but harmless for now mycolors = (i for i in colorVal) for order in grid.vor.point_region: region = grid.vor.regions[order] colortouse = next(mycolors) if -1 not in region: polygon = [grid.vor.vertices[i] for i in region] plt.fill(*zip(*polygon), color=colortouse) plt.gca().set_aspect(1.) # plt.autoscale(tight=True) # Tempting though it is to move the boundary outboard of the outermost # nodes (e.g., to the outermost corners), this is a bad idea, as the # outermost cells tend to have highly elongated shapes which make the # plot look stupid plt.xlim((np.min(grid.node_x), np.max(grid.node_x))) plt.ylim((np.min(grid.node_y), np.max(grid.node_y))) scalarMap.set_array(values) if allow_colorbar: cb = plt.colorbar(scalarMap, shrink=shrink) if grid_units[1] is None and grid_units[0] is None: grid_units = grid.axis_units if grid_units[1] == '-' and grid_units[0] == '-': plt.xlabel('X') plt.ylabel('Y') else: plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) else: plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if plot_name is not None: plt.title('%s' % (plot_name)) if var_name is not None or var_units is not None: if var_name is not None: assert type(var_name) is str if var_units is not None: assert type(var_units) is str colorbar_label = var_name + ' (' + var_units + ')' else: colorbar_label = var_name else: assert type(var_units) is str colorbar_label = '(' + var_units + ')' assert type(colorbar_label) is str assert allow_colorbar cb.set_label(colorbar_label) if color_for_background is not None: plt.gca().set_axis_bgcolor(color_for_background) if output is not None: if type(output) is str: plt.savefig(output) plt.clf() elif output: plt.show()
import numpy as np from scipy.spatial import Voronoi, voronoi_plot_2d import matplotlib.pyplot as plt from numpy.random import rand points = np.array([[0,0], [0,2], [2,2]]) #points = rand(10).reshape((5,2)) ''' points = np.array( [[ 0.22403616, 0.39571284], [ 0.85056796, 0.34780449], [ 0.36541502, 0.30568376], [ 0.38902664, 0.80566618], [ 0.66418705, 0.08285052]]) ''' vor = Voronoi(points) print 'points\n', vor.points print 'vertices\n', vor.vertices print 'ridge_points\n', vor.ridge_points print 'ridge_vertices\n', vor.ridge_vertices print 'regions\n', vor.regions print 'point_region\n', vor.point_region voronoi_plot_2d(vor) plt.show()
import numpy as np from scipy.spatial import Voronoi, voronoi_plot_2d from numpy.random import uniform from matplotlib import pyplot as plt p = uniform(0, 5, (20,2)) vor = Voronoi(p) voronoi_plot_2d(vor); plt.axes().set_aspect('equal'); plt.show()
def get_skeleton_from_outline(outline): fig, ax = plt.subplots() vor = Voronoi(outline) if vor.points.shape[1] != 2: raise ValueError("Voronoi diagram is not 2-D") points=outline plt.scatter(points[:,0],points[:,1],c='g') edges_x11=[] edges_y11=[] #plt.scatter(vor.vertices[:,0],vor.vertices[:,1],c='r') for vpair in vor.ridge_vertices: if -1 in vpair: continue v0=vor.vertices[vpair[0]] v1=vor.vertices[vpair[1]] if not is_point_inside_polygon(v0[0],v0[1],outline): continue if not is_point_inside_polygon(v1[0],v1[1],outline): continue #plt.plot([v0[0],v1[0]],[v0[1],v1[1]]) edges_x11.append(v0) edges_y11.append(v1) edges_x1=np.array(edges_x11) edges_y1=np.array(edges_y11) #detect branch [edges_x3,edges_y3]=remove_branches(edges_x1,edges_y1) print "edgesx3" print edges_x3 for i in range(len(edges_x3)): plt.plot([edges_x3[i][0],edges_y3[i][0]],[edges_x3[i][1],edges_y3[i][1]]) plt.show() sys.exit() voronoi_plot_2d(vor) plt.show() sys.exit() edges_x=[] edges_y=[] for vpair in vor.ridge_vertices: if vpair[0] >= 0 and vpair[1] >= 0: v0=vor.vertices[vpair[0]] v1=vor.vertices[vpair[1]] edges_x.append([v0[0],v1[0]]) edges_y.append([v1[0],v1[1]]) #ax.plot([v0[0], v1[0]], [v0[1], v1[1]], 'k', linewidth=2) #ax.scatter(outline[:,0],outline[:,1]) #ax.scatter(edges_x,edges_y) #plt.show() #sys.exit() #print "number of edges",len(edges_x) #print "First edge:",edges_x[0],edges_y[0] #sys.exit() # remove vertices crossing the boundary print "len edges_x",len(edges_x) ptp_bound = vor.points.ptp(axis=0) center = vor.points.mean(axis=0) print "center",center sys.exit() #https://docs.scipy.org/doc/scipy-0.12.0/reference/tutorial/spatial.html ind=-1 for pointidx, simplex in zip(vor.ridge_points, vor.ridge_vertices): simplex = np.asarray(simplex) ind=ind+1 if np.any(simplex < 0): i = simplex[simplex >= 0][0] # finite end Voronoi vertex t = vor.points[pointidx[1]] - vor.points[pointidx[0]] # tangent t /= np.linalg.norm(t) n = np.array([-t[1], t[0]]) # normal midpoint = vor.points[pointidx].mean(axis=0) direction = np.sign(np.dot(midpoint - center, n)) * n far_point = vor.vertices[i] + direction * ptp_bound.max() edges_x.append([vor.vertices[i,0], far_point[0]]) edges_y.append([vor.vertices[i,1], far_point[1]]) edges_x1=[] edges_y1=[] for i in range(len(edges_x)): if point_inside_polygon(edges_x[i][0],edges_y[i][0],outline) and point_inside_polygon(edges_x[i][1],edges_y[i][1],outline): edges_x1.append(edges_x[i]) edges_y1.append(edges_y[i]) edges_x1=np.array(edges_x1) edges_y1=np.array(edges_y1) #detect branch delta=0.0001 edges_x2=[]; edges_y2=[]; while True: for i in range(len(edges_x1)): p1=np.sum((abs(edges_x1-edges_x1[i][0])<delta) & (abs(edges_y1-edges_y1[i][0])<delta))>1 p2=np.sum((abs(edges_x1-edges_x1[i][1])<delta) & (abs(edges_y1-edges_y1[i][1])<delta))>1 if p1 and p2: edges_x2.append([edges_x1[i][0],edges_x1[i][1]]) edges_y2.append([edges_y1[i][0],edges_y1[i][1]]) if (len(edges_x1)-len(edges_x2))<=2: edges_x3=np.array(edges_x2) edges_y3=np.array(edges_y2) break else: edges_x1 = np.array(edges_x2) edges_y1 = np.array(edges_y2) edges_x2=[]; edges_y2=[]; edges_x3=np.array(edges_x1) edges_y3=np.array(edges_y1) #TODO - missing removing cycles edges_x=edges_x3 edges_y=edges_y3 #sort the points vx2=[] vy2=[] colorline(edges_x,edges_y) adjust_bounds(ax, outline) plt.show() for i in range(len(edges_x2)): #find the first point if np.sum(np.sum((abs(edges_x-edges_x[i][0])<delta) & (abs(edges_y-edges_y[i][0])<delta)))==1: vx2=edges_x[i] vy2=edges_y[i] break elif np.sum(np.sum((abs(edges_x-edges_x[i][1])<delta) & (abs(edges_y-edges_y[i][1])<delta)))==1: vx2=np.fliplr(edges_x[i]) vy2=np.fliplr(edges_x[i]) break k=1 ''' FIND THE ERROR HERE:File "utils.py", line 119, in get_skeleton_from_outline f1=np.where((abs(edges_x[:,0]-vx2[k])<delta) & (abs(edges_y[:,0]-vy2[k])<delta) & ((abs(edges_x[:,1]-vx2[k-1])>=delta) | (abs(edges_y[:,1]-vy2[k-1])> =delta))) IndexError: too many indices for array compare to test.py Things left: I know how to segment get the polygon find the outline find the skeleton find the mesh now i need to find how to get a slice of the mesh and sum all pixels there ''' while True: # in this cycle sort all points after the first one f1=np.where((abs(edges_x[:,0]-vx2[k])<delta) & (abs(edges_y[:,0]-vy2[k])<delta) & ((abs(edges_x[:,1]-vx2[k-1])>=delta) | (abs(edges_y[:,1]-vy2[k-1])>=delta))) f2=np.where((abs(edges_x[:,1]-vx2[k])<delta) & (abs(edges_y[:,1]-vy2[k])<delta) & ((abs(edges_x[:,0]-vx2[k-1])>=delta) | (abs(edges_y[:,0]-vy2[k-1])>=delta))) if len(f1[0])>0: vx2=np.append(vx2,edges_x[f1[0],1]) vy2=np.append(vy2,edges_y[f1[0],1]) elif len(f2[0])>0: vx2=np.append(vx2,edges_x[f2[0],0]) vy2=np.append(vy2,edges_y[f2[0],0]) else: break k=k+1 stp=1 skel=np.zeros([len(vx2),2]) skel_diff=np.zeros([len(vx2)-1,2]) skel[0,0]=vx2[0] skel[0,1]=vy2[0] for i in range(1,len(vx2)): skel[i,0]=vx2[i] skel[i,1]=vy2[i] skel_diff[i-1,0]=vx2[i]-vx2[i-1] skel_diff[i-1,1]=vy2[i]-vy2[i-1] #interpolate skeleton to equal step, extend outside of the cell and smooth l=np.cumsum(np.append(0,np.sum(skel_diff*skel_diff,1))) skelx_interp = np.interp(np.linspace(0,l[-1],l[-1]/stp),l,vx2) skely_interp = np.interp(np.linspace(0,l[-1],l[-1]/stp),l,vy2) skel_interp=np.zeros([len(skelx_interp),2]) for i in range(len(skelx_interp)): skel_interp[i,0]=skelx_interp[i] skel_interp[i,1]=skely_interp[i] colorline(vx2,vy2) colorline(skelx_interp,skely_interp) adjust_bounds(ax, points) plt.show() lng0 = l[-1] lng=15 sz = lng0/stp coord = np.append(points,points[0]) coord=coord.reshape(len(points)+1,2) skel2 = np.append(np.append(skel_interp[0]*(lng/stp+1) - skel_interp[1]*lng/stp,skel_interp),skel_interp[-1]*(lng/stp+1) - skel_interp[-2]*lng/stp) skel2=skel2.reshape(2+len(skel_interp),2) skel2_diff=np.zeros([len(skel2[:,0])-1,2]) for i in range(1,len(skel2[:,0])): skel2_diff[i-1,0]=skel2[i,0]-skel2[i-1,0] skel2_diff[i-1,1]=skel2[i,1]-skel2[i-1,1] l=np.cumsum(np.append(0,np.sum(skel2_diff*skel2_diff,1))) l,i = np.unique(l,return_index=True); skel2 = skel2[i,:]; L=80 [tmp1,tmp2,indS,indC]=skeleton_to_mesh.intxyMulti(skel2[2:,0],skel2[2:,1],coord[:,0],coord[:,1]) aa=np.array([min(skeleton_to_mesh.modL(indC,1)),min(skeleton_to_mesh.modL(indC,L/2+1))]) tmp1=aa.argmin() prevpoint=aa[tmp1] if prevpoint==1: prevpoint=L/2 lng=15 return skel
#!/Users/simurgh/anaconda/bin/python import json import os import matplotlib.pyplot as plt from scipy.spatial import Voronoi, voronoi_plot_2d import numpy as np import mplleaflet # Load up the geojson data filename = ('probes.geojson') with open(filename) as f: gj = json.load(f) # Grab the coordinates (longitude, latitude) from the features, which we # know are Points xy = np.array([feat['geometry']['coordinates'] for feat in gj['features']]) #plt.hold(True) # Plot the ixp as red dots #plot(xy[:,0], xy[:,1], 'rx') vor_polygon = Voronoi(xy) voronoi_plot_2d(vor_polygon, show_vertices=False) mapfile = 'probe-voronoi-cells.html' # Create the map. Save the file to html mplleaflet.show(path=mapfile)
def show(self): voronoi_plot_2d(self)
def plot_cells_2d(self): voronoi_plot_2d(self.vor)
#ax1.triplot(cmy,cmx,tri.simplices.copy()) ax2.scatter(cmy,cmx,s=rga,c=aratio,alpha = 0.6) ax2.set_xlim([0,len_lum[1]]) ax2.set_ylim([0,len_lum[0]]) ax2.invert_yaxis() ax2.set_aspect('equal',adjustable='box') ax3.set_title('Connectivity') if len(cmx) > 0: ax3.triplot(cmy,cmx,tri.simplices.copy()) ax3.set_xlim([0,len_lum[1]]) ax3.set_ylim([0,len_lum[0]]) ax3.invert_yaxis() ax3.set_aspect('equal',adjustable='box') ax4.set_title('Voronoi') if len(cmx) > 0: voronoi_plot_2d(vor,ax4) ax4.set_xlim([0,len_lum[1]]) ax4.set_ylim([0,len_lum[0]]) ax4.invert_yaxis() ax4.set_aspect('equal',adjustable='box') plt.tight_layout() #plt.show() new_file_name = "voronoi_cluster_cutoff_"+ str(cutoff) +"_"+magfile out_file = os.path.join(directory,new_file_name) fig.savefig(out_file,dpi=300)