def construct_hex_grid(XYs, tiles_x, tiles_y): """ Build hexagon grid over study area with user-defined number of tiles. Parameters ---------- XYs : Geoseries series Series containing X and Y coordinates. tiles_x : integer Integer declaring number of tiles along X axis. tiles_y : integer Integer declaring number of tiles along Y axis. Returns ------- grid : GeoDataFrame Dataframe GeoDataFrame with hexagon grids as shapely polygons. """ minx, miny, maxx, maxy = XYs.total_bounds padding = 1.e-9 * (maxx - minx) minx -= padding maxx += padding dx = (maxx - minx) / tiles_x dy = (maxy - miny) / tiles_y tiles_x1 = tiles_x + 1 tiles_y1 = tiles_y + 1 n = tiles_x1 * tiles_y1 + tiles_x * tiles_y offsets = np.zeros((n, 2), float) offsets[:tiles_x1 * tiles_y1, 0] = np.repeat(np.arange(tiles_x1), tiles_y1) offsets[:tiles_x1 * tiles_y1, 1] = np.tile(np.arange(tiles_y1), tiles_x1) offsets[tiles_x1 * tiles_y1:, 0] = np.repeat(np.arange(tiles_x) + 0.5, tiles_y) offsets[tiles_x1 * tiles_y1:, 1] = np.tile(np.arange(tiles_y), tiles_x) + 0.5 offsets[:, 0] *= dx offsets[:, 1] *= dy offsets[:, 0] += minx offsets[:, 1] += miny polygon = [dx, dy / 3] * np.array([[.5, -.5], [.5, .5], [0., 1.], [-.5, .5], [-.5, -.5], [0., -1.]]) collection = PolyCollection([polygon], offsets=offsets) hex_polys = collection.get_paths()[0].vertices hex_array = [] for xs, ys in collection.get_offsets(): hex_x = np.add(hex_polys[:, 0], xs) hex_y = np.add(hex_polys[:, 1], ys) hex_array.append(Polygon(np.vstack([hex_x, hex_y]).T)) hex_grid = gpd.GeoDataFrame({'geometry': hex_array}) return hex_grid
def test_poly_collection_2d_to_3d_empty(): poly = PolyCollection([]) art3d.poly_collection_2d_to_3d(poly) assert isinstance(poly, art3d.Poly3DCollection) assert poly.get_paths() == [] fig, ax = plt.subplots(subplot_kw=dict(projection='3d')) ax.add_artist(poly) minz = poly.do_3d_projection() assert np.isnan(minz) # Ensure drawing actually works. fig.canvas.draw()
def zoom_in_area(self, fill_area: PolyCollection): paths = fill_area.get_paths() verts = paths[0].vertices beginning = np.min(verts[:, 0]) end = np.max(verts[:, 0]) # print(beginning, end) indmin, indmax = 0, 0 if self.use_dates: indmin, indmax = self.get_index_from_datetime(beginning, end) else: indmin, indmax = np.searchsorted(self.x, (int(beginning), int(end))) indmax = min(len(self.x) - 1, indmax) thisx = self.x[indmin:indmax] thisy = self.y[indmin:indmax] self.line2.set_data(thisx, thisy) ax2.set_xlim(thisx[0], thisx[-1]) ax2.set_ylim(thisy.min(), thisy.max())
def test_poly_collection_2d_to_3d_empty(): poly = PolyCollection([]) art3d.poly_collection_2d_to_3d(poly) assert isinstance(poly, art3d.Poly3DCollection) assert poly.get_paths() == []
def test_poly_collection_2d_to_3d_empty(): poly = PolyCollection([]) art3d.poly_collection_2d_to_3d(poly) assert isinstance(poly, art3d.Poly3DCollection) assert poly.get_paths() == []
def plotCurrent(self, dtfrom, fnamebase): #self.figure.clf() #self.canvas.draw() #self.loadModel() self.progressBar.setValue(51) frmDate = self.dtFrom.dateTime() #print 'Plotting till date: ' + dtfrom.date().toString() # get velocity nearest to current time ##dtnow = dt.datetime.utcnow() + dt.timedelta(hours=0) day = dtfrom.date().day() month = dtfrom.date().month() year = dtfrom.date().year() hour = dtfrom.time().hour() minute = dtfrom.time().minute() second = dtfrom.time().second() msecond = dtfrom.time().msec() #print dir(dtnow) #print dtnow.time() startdt = dt.datetime(year, month, day, hour, minute, second, msecond) #print startdt #print start istart = netCDF4.date2index(startdt,self.time_var,select=self.interp_method) layer = 0 # surface layer u = self.nc.variables[self.uvar][istart, layer, :] v = self.nc.variables[self.vvar][istart, layer, :] mag = numpy.sqrt((u*u)+(v*v)) #print start #print istart self.progressBar.setValue(63) # Now try plotting speed and vectors with Basemap using a PolyCollection m = Basemap(projection='merc', llcrnrlat=self.lat.min(), urcrnrlat=self.lat.max(), llcrnrlon=self.lon.min(), urcrnrlon=self.lon.max(), lat_ts=self.lat.mean(), resolution=None) # project from lon,lat to mercator xnode, ynode = m(self.lon, self.lat) xc, yc = m(self.lonc, self.latc) nv = self.nc.variables[self.nvvar][:].T - 1 # create a TRI object with projected coordinates tri = Tri.Triangulation(xnode, ynode, triangles=nv) self.progressBar.setValue(77) sig_lay = self.nc.variables['siglay'] zeta = self.nc.variables['zeta'] # make a PolyCollection using triangles verts = concatenate((tri.x[tri.triangles][..., None], tri.y[tri.triangles][..., None]), axis=2) colorlut = [] fid = 0 for poly in verts: fid = fid + 1 collection = PolyCollection(verts) collection.set_edgecolor('none') self.progressBar.setValue(81) timestamp=startdt.strftime('%Y-%m-%d %H:%M:%S') # set the magnitude of the polycollection to the speed collection.set_array(mag) #sys.exit(1) collection.norm.vmin=0 collection.norm.vmax=0.5 #for path in collection.get_paths(): cmap =collection.cmap featurecount = fid redArray = matplotlib.colors.makeMappingArray(featurecount,cmap._segmentdata['red'], 1.0) greenArray = matplotlib.colors.makeMappingArray(featurecount,cmap._segmentdata['green'], 1.0) blueArray = matplotlib.colors.makeMappingArray(featurecount,cmap._segmentdata['blue'], 1.0) fid = 0 for path in collection.get_paths(): tricolor = self.makehexcolor(redArray[fid], greenArray[fid], blueArray[fid]) ##print tricolor name = "polygon#" + str(fid) colorlut.append(tricolor) #self.dbcur.execute("insert into polystyle values(?,?)",[name,str(tricolor) ]) fid = fid + 1 ds, lyr = self.init_vector(fnamebase) fid = 0 for poly in verts: #print "polygon" linecoords = [] feat = ogr.Feature( lyr.GetLayerDefn()) feat.SetField( "idd", "idd1" ) name = "polygon#" + str(fid) feat.SetField( "name", name ) feat.SetField( "color", colorlut[fid] ) fid = fid + 1 path = ogr.Geometry(ogr.wkbPolygon) extring = ogr.Geometry(ogr.wkbLinearRing) #path.getExteriorRing(); for coord in poly: ##print coord cc = m(coord[0],coord[1],inverse=True) #print cc x = cc[0] y = cc[1] pt = fid tstamp = startdt.strftime('%Y-%m-%d %H:%M:%S') z = 0 #z = sig_lay[pt:pt] * (zeta[pt:pt] - self.nc.variables[self.hvar][pt:pt]) #print (zeta[tstamp,pt]) # - self.nc.variables[self.hvar][pt]) #print zeta[:pt] #sys.exit(1) extring.AddPoint(x, y,z) extring.CloseRings() polygon = ogr.Geometry(ogr.wkbPolygon) polygon.AddGeometry(extring) feat.SetGeometry(polygon) if lyr.CreateFeature(feat) != 0: print "Failed to create feature in shapefile.\n" sys.exit( 1 ) ##else: ##print 'creaating feature' + str(feat.GetFID()); feat.Destroy() lyr.SyncToDisk() ax2=self.figure.add_subplot(111) coll = m.drawmapboundary(fill_color='0.3') self.progressBar.setValue(89) #m.drawcoastlines() #m.fillcontinents() # add the speed as colored triangles ax2.add_collection(collection) # add polygons to axes on basemap instance # add the vectors #Q = m.quiver(xc,yc,u,v,scale=30) Q = m.quiver(xc, yc, u, v, scale=100); ##self.progressBar.setValue(94) # add a key for the vectors qk = plt.quiverkey(Q,0.1,0.1,0.20,'0.2 m/s',labelpos='W') title('FVCOM Surface Current speed at %s UTC' % timestamp) # refresh canvas self.progressBar.setValue(97) self.canvas.draw() self.progressBar.setValue(100) self.animate(False) print "returning..." outfile = fnamebase + ".shp" return outfile
def set_data(self, zname=None, zdata=None, zcolor=None, plot_type="poly"): if zdata != None: if plot_type is "poly": if zname not in self.clts: #plottables['plotted']:#self.pd.list_data(): clt = PolyCollection( [], alpha=0.5, antialiased=True ) #, rasterized=False, antialiased=False) if zcolor is not None: clt.set_color(colorConverter.to_rgba(zcolor)) self.clts[zname] = clt self.axe.add_collection(self.clts[zname]) self.clts[zname].set_verts(zdata) elif plot_type is "line": if zname not in self.clts: clt = LineCollection( zdata) #, linewidths=(0.5, 1, 1.5, 2), #linestyles='solid', colors=("red", "blue", "green")) if zcolor is not None: clt.set_color(zcolor) else: clt.set_array(arange(len(zdata))) else: self.clts[zname].set_verts(zdata) #self.set_xlim(x.min(), x.max()) #self.set_ylim(ys.min(), ys.max()) elif plot_type is "scatter": self.axe.scatter(zdata, zdata) elif plot_type is "colormap": self.axe.pcolormesh(x, y, z) if 0: x = arange(3) ys = array([x + i for i in arange(5)]) #xdata=arange(len(getattr(self, zname))) data = [list(zip(x, y)) for y in ys] line_segments = LineCollection(data, linewidths=1, linestyles='solid', colors=mycolors) print data print len(data) #print line_segments.properties() #print line_segments.set_hatch("O") #print dir(self.axe) print[p.vertices for p in line_segments.get_paths()] #) print line_segments.get_segments() line_segments.set_array(arange(len(data))) x = arange(3) ys = array([x + i for i in arange(2)]) #xdata=arange(len(getattr(self, zname))) data = [list(zip(x, y)) for y in ys] line_segments.set_verts(data) #self.axe.add_collection(line_segments, autolim=True) clt = self.axe.scatter(x, x) #clt.set_linestyle("solid") print dir(clt) print clt.get_paths() if 0: #clt=QuadMesh(0, 0, [1]) n = 12 x = linspace(-1.5, 1.5, n) y = linspace(-1.5, 1.5, n * 2) X, Y = meshgrid(x, y) print X Qx = cos(Y) - cos(X) Qz = sin(Y) + sin(X) Qx = (Qx + 1.1) Z = sqrt(X**2 + Y**2) / 5 Z = (Z - Z.min()) / (Z.max() - Z.min()) Zm = ma.masked_where(fabs(Qz) < 0.5 * amax(Qz), Z) #ax = fig.add_subplot(121) #self.axe.set_axis_bgcolor("#bdb76b") clt = self.axe.pcolormesh(Z) #print dir(clt) self.axe.set_title('Without masked values')