def modis_cover_from_gring(h,resolution=7,ntri_max=1000): "Read ArchiveMetadata.0 from file and extract GRING, creating STARE spatial cover." archive_metadata = h.attributes()['ArchiveMetadata.0'] metadata = parse_hdfeos_metadata(archive_metadata) gring_seq=np.array(eval(metadata['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTSEQUENCENO']['VALUE'])[:],dtype=np.int)-1 gring_lon=np.array(eval(metadata['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLONGITUDE']['VALUE'])[:],dtype=np.double) gring_lat=np.array(eval(metadata['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLATITUDE']['VALUE'])[:],dtype=np.double) return ps.to_hull_range_from_latlon(gring_lat[gring_seq],gring_lon[gring_seq],resolution,ntri_max)
def make_hull(lat0,lon0,resolution0): hull0 = ps.to_hull_range_from_latlon(lat0,lon0,resolution0) print('hull0 len: ',len(hull0),type(hull0)) lath0,lonh0,lathc0,lonhc0 = ps.to_vertices_latlon(hull0) lons0,lats0,intmat0 = ps.triangulate(lath0,lonh0) print('lons0 len: ',len(lons0)) print('intmat len: ',len(intmat0),type(intmat0)) triang0 = tri.Triangulation(lons0,lats0,intmat0) for i in range(len(intmat0)): print(i,intmat0[i],lons0[intmat0[i]],lats0[intmat0[i]]) print('triang ',triang0.triangles.shape) # exit() return lats0,lons0,triang0,hull0
def test_intersect_single_res(self): resolution = 6 resolution0 = resolution lat0 = numpy.array([10, 5, 60, 70], dtype=numpy.double) lon0 = numpy.array([-30, -20, 60, 10], dtype=numpy.double) hull0 = pystare.to_hull_range_from_latlon(lat0, lon0, resolution0) resolution1 = 6 lat1 = numpy.array([10, 20, 30, 20], dtype=numpy.double) lon1 = numpy.array([-60, 60, 60, -60], dtype=numpy.double) hull1 = pystare.to_hull_range_from_latlon(lat1, lon1, resolution1) intersectedFalse = pystare.intersect(hull0, hull1, multiresolution=False) intersectedTrue = pystare.intersect(hull0, hull1, multiresolution=True) # See examples/test_intersect_single_res.py self.assertEqual(328, len(intersectedFalse)) # self.assertEqual(172, len(intersectedTrue)) # self.assertEqual(82, len(intersectedTrue)) self.assertEqual(79, len(intersectedTrue))
def from_boundary(boundary, level=-1, nonconvex=True, force_ccw=False): """ Return a range of indices covering the region circumscribed by the polygon. Node orientation is relevant and CW """ if force_ccw and not boundary.is_ccw: boundary.coords = list(boundary.coords)[::-1] latlon = boundary.coords.xy lon = latlon[0] lat = latlon[1] if nonconvex: range_indices = pystare.to_nonconvex_hull_range_from_latlon( lat, lon, level) else: range_indices = pystare.to_hull_range_from_latlon(lat, lon, level) return range_indices
close=True) ax.plot(lonplot, latplot, True, transform=ccrs.Geodetic()) ax.add_patch( plt.Circle((goes_b3_lon_flat[i], goes_b3_lat_flat[i]), radius=goes_b3_elemRes * 180.0 / (np.pi * 6371.0), fill=False, transform=ccrs.Geodetic())) if False: i = 2 print('Add a "bounding box" around point ', i) lonplot, latplot = gd.bbox_lonlat(goes_b3_lat_flat[i], goes_b3_lon_flat[i], goes_b3_elemRes, close=False) hull = ps.to_hull_range_from_latlon(latplot, lonplot, 13, 300) # hull = ps.to_hull_range_from_latlon(latplot,lonplot,15,300) # Looks cool! gd.plot_indices(hull, c='b', transform=ccrs.Geodetic(), lw=1.5) print('Compare the goes_b3_indices with the "hulled bounding box."') print('cmp len goes_b3_indices: ', len(goes_b3_indices), goes_b3_indices.shape) print('cmp len hull: ', len(hull), hull.shape) cmp = ps.cmp_spatial(goes_b3_indices, hull) cmpr = ps.cmp_spatial(hull, goes_b3_indices) ngoes_b3_indices = len(goes_b3_indices) nhull = len(hull) for i in range(ngoes_b3_indices): for j in range(nhull): if ((cmp[i * nhull + j] != 0 or cmpr[j * ngoes_b3_indices + i]) != 0): ping = "***"
def main(): ########################################################################### # Data source dataPath = "/home/mrilee/data/" ########################################################################### # MODIS modis_base = "MOD05_L2." # modis_item = "A2005349.2120.061.2017294065852" # modis_time_start = "2005-12-15T21:20:00" modis_item = "A2005349.2125.061.2017294065400" modis_time_start = "2005-12-15T21:25:00" modis_suffix = ".hdf" modis_filename = modis_base + modis_item + modis_suffix # hdf = SD(dataPath+modis_filename,SDC.READ) # ds_wv_nir = hdf.select('Water_Vapor_Near_Infrared') fmt_suffix = ".h5" workFileName = "sketchG." + modis_base + modis_item + fmt_suffix print('loading ', workFileName) workFile = h5.File(workFileName, 'r') sids = workFile['/image']['stare_spatial'] lat = workFile['/image']['Latitude'] lon = workFile['/image']['Longitude'] data = workFile['/image']['Water_Vapor_Near_Infrared'] workFile.close() modis_min = np.amin(data) modis_max = np.amax(data) sids = sids - 1 ########################################################################### # GOES goes_file = 'sketch9.2005.349.213015.h5' workFileName = goes_file workFile = h5.File(workFileName, 'r') goes_sids = workFile['/image']['stare_spatial'] goes_data = workFile['/image']['goes_b3'] workFile.close() print('goes mnmx: ', np.amin(goes_data), np.amax(goes_data)) goes_min = np.amin(goes_data) goes_max = np.amax(goes_data) goes_sids = goes_sids - 1 ########################################################################### # Plotting nrows = 2 ncols = 3 nrows = 1 ncols = 1 proj = ccrs.PlateCarree() # proj = ccrs.Mollweide() # proj = ccrs.Mollweide(central_longitude=-160.0) transf = ccrs.Geodetic() # https://stackoverflow.com/questions/33942233/how-do-i-change-matplotlibs-subplot-projection-of-an-existing-axis # plt.figure() fig, axs = plt.subplots(nrows=nrows, ncols=ncols, subplot_kw={'projection': proj}) # axs.set_facecolor('k') # axs.patch.set_facecolor('black') # axs.set_facecolor('black') if nrows * ncols == 1: fig = [fig] axs = [axs] goes_line = [False, False, False] modis_line = [False, False, False] cover_plot = [True, True, True] goes_plot_1 = [True, False, True] goes_plot_1_points = [True, False, True] modis_plot_1 = [False, True, True] plt_show_1 = [False, False, True] goes_line = [False, False, False, True, False, True] modis_line = [False, False, False, False, True, True] cover_plot = [False, False, False, False, False, False] goes_plot_1 = [True, False, True, True, False, True] goes_plot_1_points = [False, False, False, True, False, True] modis_plot_1 = [False, True, True, False, True, True] modis_plot_1_points = [False, False, False, False, True, True] plt_show_1 = [False, False, True, False, False, True] irow = [0, 0, 0, 1, 1, 1] icol = [0, 1, 2, 0, 1, 2] coastline_color = 'black' coastline_color = 'black' # blend blend_tripcolor_1 = True blend_tripcolor_1_res = 10 # blend_tripcolor_1_res = 9 # FFE # blend_tripcolor_1_res = 6 # Test blend_tripcolor_1_cmap = None blend_tripcolor_1_alpha = 1 blend_tripcolor_1_gamma_g = 0.65 blend_tripcolor_1_gamma_m = 0.65 if blend_tripcolor_1: goes_plot_1 = [False] * 6 modis_plot_1 = [False] * 6 # coastline_color = 'white' coastline_color = 'black' # 2020-0125 pix 1 # goes_plot_1_res = 9 # modis_plot_1_res = 9 # # goes_plot_1_res = 6 # modis_plot_1_res = 6 # # plot_1_res = 9 # FFE plot_1_res = 6 goes_plot_1_res = plot_1_res modis_plot_1_res = plot_1_res # Colors goes_plot_1_tripcolor = 'Reds' modis_plot_1_tripcolor = 'Blues' # common_alpha = 0.7 goes_plot_1_alpha = common_alpha modis_plot_1_alpha = common_alpha # recalculate=[True,False,False,True,False,False] recalculate = [True, False, True, True, False, True] cover_rads = [2.0, 0, 2, 0.125, 0, 0.125] # cover_rads =[2.0,0,0, 0.125,0,0] circle_plot = [False, False, False, False, False, False] circle_color = [ 'White', 'lightgrey', 'White', 'navajowhite', 'khaki', 'White' ] modis_scatter_color = [ 'darkcyan', 'darkcyan', 'darkcyan', 'darkcyan', 'cyan', 'cyan' ] nodes_cover = [1, 2, 1, 1, 2, 1] # 1 == goes, 2 == modis, 0 == None # nodes_cover=[0,0,0,0,0,0] subplot_title = [ "ROI+GOES", "ROI+MODIS", "ROI+GOES+MODIS", None, None, None ] # for iter in range(6): # for iter in [2,5]: if True: iter = 2 ########################################################################### if recalculate[iter]: print('recalculating iter = ', iter) ########################################################################### cover_resolution = 11 # cover_resolution = 12 cover_type = 'circular' # cover_resolution = 6 #+ cover_resolution = 5 #+ cover_type = 'bounding_box' if cover_type == 'circular': ########################################################################### # HI 28.5N 177W # Near the Big Island cover_lat = 19.5 - 0.375 cover_lon = -155.5 + 0.375 # Midway Island # cover_lat = 28.2 # cover_lon = -177.35 # Ni'ihau # cover_lat = 21.9 # cover_lon = -160.17 cover_rad = cover_rads[iter] cover = ps.to_circular_cover(cover_lat, cover_lon, cover_rad, cover_resolution) # ,range_size_limit=2000) elif cover_type == 'bounding_box': # Set cover to "bounding box." cover_lat = np.array([15, 15, 38, 38], dtype=np.float) cover_lon = np.array([-174, -145, -145, -174], dtype=np.float) cover = ps.to_hull_range_from_latlon(cover_lat, cover_lon, cover_resolution) cover_cat = catalog(resolution=cover_resolution, sids=cover) cover_sids_min = np.amin(cover) cover_sids_max = np.amax(cover) # Need to convert to terminator cover_sids_max = gd.spatial_terminator(cover_sids_max) # for k in list(cover_cat.sdict.keys()): # print('cc: ',hex(k)) ########################################################################### # gm_cat_resolution = 5 gm_catalog = catalog(resolution=gm_cat_resolution) k = 0 for i in range(10): while (goes_sids[k] < 0): k = k + 1 # print('adding: ','0x%016x'%goes_sids[k],k) gm_catalog.add('goes', goes_sids[k], goes_data[k]) k = k + 1 for i in range(10): # print('adding: ','0x%016x'%sids[i]) gm_catalog.add('modis', sids[i], data[i]) k = 0 # for i in range(10): idx = np.arange( goes_sids.size)[np.where((goes_sids > cover_sids_min) & (goes_sids < cover_sids_max))] for k in range(len(idx)): # while(goes_sids[k]<0): # k=k+1 if goes_sids[idx[k]] > 0: cover_cat.add_to_entry('goes', goes_sids[idx[k]], goes_data[idx[k]]) # k=k+1 idx = np.arange(sids.size)[np.where((sids > cover_sids_min) & (sids < cover_sids_max))] for k in range(len(idx)): if sids[idx[k]] > 0: cover_cat.add_to_entry('modis', sids[idx[k]], data[idx[k]]) # print(yaml.dump(gm_catalog)) # exit() # ########################################################################### print('plotting iter ', iter) if nrows * ncols == 1: ax = axs[0] else: ax = axs[irow[iter], icol[iter]] if subplot_title[iter] is not None: ax.set_title(subplot_title[iter]) if False: ax.set_global() if True: ax.coastlines(color=coastline_color) if iter == 0: x0 = 0.05 y0 = 0.025 dy = 0.025 plt.figtext(x0, y0 + 0 * dy, "MODIS: " + "sketchG." + modis_base + modis_item + fmt_suffix + ', Water_Vapor_Near_Infrared, resolution = %i' % (sids[10000] & 31), fontsize=10) k = 0 while goes_sids[k] < 0: k = k + 1 plt.figtext(x0, y0 + 1 * dy, "GOES: " + goes_file + ' BAND_3 (6.7mu), resolution = %i' % (goes_sids[k] & 31), fontsize=10) if cover_type == 'circular': plt.figtext( x0, y0 + 2 * dy, "ROI Cover: resolution = %d, radius = %0.2f (upper) %0.3f (lower) degrees, center = 0x%016x" % (cover_resolution, cover_rads[0], cover_rads[3], ps.from_latlon(npf64([cover_lat]), npf64([cover_lon]), cover_resolution)[0]), fontsize=10) # plt.show() # exit() if False: lli = ps.triangulate_indices(cover) ax.triplot(tri.Triangulation(lli[0], lli[1], lli[2]), 'g-', transform=transf, lw=1, markersize=3) if True: if goes_plot_1[iter]: cc_data = cover_cat.get_all_data('goes') csids, sdat = zip(*[cd.as_tuple() for cd in cc_data]) if goes_plot_1_points[iter]: glat, glon = ps.to_latlon(csids) # csids_at_res = list(map(gd.spatial_clear_to_resolution,csids)) # cc_data_accum = dict() # for cs in csids_at_res: # cc_data_accum[cs] = [] # for ics in range(len(csids_at_res)): # cc_data_accum[csids_at_res[ics]].append(sdat[ics]) # for cs in cc_data_accum.keys(): # if len(cc_data_accum[cs]) > 1: # cc_data_accum[cs] = [sum(cc_data_accum[cs])/(1.0*len(cc_data_accum[cs]))] # tmp_values = np.array(list(cc_data_accum.values())) # vmin = np.amin(tmp_values) # vmax = np.amax(np.array(tmp_values)) cc_data_accum, vmin, vmax = gd.simple_collect( csids, sdat, force_resolution=goes_plot_1_res) # print('a100: ',cc_data) # print('cc_data type: ',type(cc_data)) # print('cc_data[0] type: ',type(cc_data[0])) for cs in cc_data_accum.keys(): # print('item: ',hex(cs),cc_data_accum[cs]) lli = ps.triangulate_indices([cs]) triang = tri.Triangulation(lli[0], lli[1], lli[2]) cd_plt = np.array(cc_data_accum[cs]) # print('cd_plt type ',type(cd_plt)) # print('cd_plt shape ',cd_plt.shape) # print('cd_plt type ',type(cd_plt[0])) if goes_line[iter]: ax.triplot(triang, 'r-', transform=transf, lw=1.5, markersize=3, alpha=0.5) # ax.tripcolor(triang,facecolors=cd_plt,vmin=goes_min,vmax=goes_max,cmap='Reds',alpha=0.4) ax.tripcolor(triang, facecolors=cd_plt, edgecolors='k', lw=0, shading='flat', vmin=vmin, vmax=vmax, cmap=goes_plot_1_tripcolor, alpha=goes_plot_1_alpha) # for cd in cc_data: # lli = ps.triangulate_indices([cd.sid]) # triang = tri.Triangulation(lli[0],lli[1],lli[2]) # cd_plt = np.array([cd.datum]) # if goes_line[iter]: # ax.triplot(triang,'r-',transform=transf,lw=3,markersize=3,alpha=0.5) # ax.tripcolor(triang,facecolors=cd_plt,vmin=goes_min,vmax=goes_max,cmap='Reds',alpha=0.4) if modis_plot_1[iter]: cc_data_m = cover_cat.get_all_data('modis') csids, sdat = zip(*[cd.as_tuple() for cd in cc_data_m]) # mlat,mlon = ps.to_latlon(csids) cc_data_m_accum, vmin, vmax = gd.simple_collect( csids, sdat, force_resolution=modis_plot_1_res) for cs in cc_data_m_accum.keys(): lli = ps.triangulate_indices([cs]) triang = tri.Triangulation(lli[0], lli[1], lli[2]) cd_plt = np.array(cc_data_m_accum[cs]) # print('lli[0] len ',len(lli[0])) # print('cd_plt len ', len(cd_plt)) # print('cd_plt type ',type(cd_plt)) # print('cd_plt shape ',cd_plt.shape) # print('cd_plt type ',type(cd_plt[0])) if modis_line[iter]: ax.triplot(triang, 'b-', transform=transf, lw=1.5, markersize=3, alpha=0.5) # ax.tripcolor(triang,facecolors=cd_plt,vmin=goes_min,vmax=goes_max,cmap='Blues',alpha=0.4) ax.tripcolor(triang, facecolors=cd_plt, edgecolors='k', lw=0, shading='flat', vmin=vmin, vmax=vmax, cmap=modis_plot_1_tripcolor, alpha=modis_plot_1_alpha) # for cd in cc_data_m: # lli = ps.triangulate_indices([cd.sid]) # triang = tri.Triangulation(lli[0],lli[1],lli[2]) # cd_plt = np.array([cd.datum]) # if modis_line[iter]: # ax.triplot(triang,'b-',transform=transf,lw=1,markersize=3,alpha=0.5) # ax.tripcolor(triang,facecolors=cd_plt,vmin=modis_min,vmax=modis_max,cmap='Blues',alpha=0.4) if modis_plot_1_points[iter]: mlat, mlon = ps.to_latlon(csids) ax.scatter(mlon, mlat, s=8, c=modis_scatter_color[iter]) # ax.scatter(mlon,mlat,s=8,c='cyan') # ax.scatter(mlon,mlat,s=8,c='darkcyan') # blend_tripcolor_1 = False # blend_tripcolor_res_1 = 6 # blend_tripcolor_1_cmap = None # blend_tripcolor_1_alpha = 1 if blend_tripcolor_1: cc_data = cover_cat.get_all_data('goes') csids, sdat = zip(*[cd.as_tuple() for cd in cc_data]) cc_data_accum, vmin, vmax = gd.simple_collect( csids, sdat, force_resolution=blend_tripcolor_1_res) cc_data_m = cover_cat.get_all_data('modis') csids_m, sdat_m = zip(*[cd.as_tuple() for cd in cc_data_m]) cc_data_m_accum, vmin_m, vmax_m = gd.simple_collect( csids_m, sdat_m, force_resolution=blend_tripcolor_1_res) data_accum_keys = set() for cs in cc_data_accum.keys(): data_accum_keys.add(cs) for cs in cc_data_m_accum.keys(): data_accum_keys.add(cs) for cs in data_accum_keys: # print('item: ',hex(cs),cc_data_accum[cs]) lli = ps.triangulate_indices([cs]) triang = tri.Triangulation(lli[0], lli[1], lli[2]) try: cd_plt_g = (np.array(cc_data_accum[cs]) - vmin) / (vmax - vmin) cd_plt_g = cd_plt_g**blend_tripcolor_1_gamma_g except: cd_plt_g = np.array([0]) try: cd_plt_m = (np.array(cc_data_m_accum[cs]) - vmin_m) / (vmax_m - vmin_m) cd_plt_m = cd_plt_m**blend_tripcolor_1_gamma_m except: cd_plt_m = np.array([0]) ###### # blend 1 & 2 # cd_plt = np.array([[cd_plt_g,0,cd_plt_m]]) ###### # blend 3 # print('len: ',cd_plt_g.shape,cd_plt_m.shape) cd_plt = np.array([[ cd_plt_g[0], 0.5 * (cd_plt_g + cd_plt_m)[0], cd_plt_m[0] ]]) cd_cmp = colors_to_cmap(cd_plt) zs = np.asarray(range(3), dtype=np.float) / 2.0 ax.tripcolor( triang, zs, cmap=cd_cmp # ,facecolors=cd_plt , edgecolors='k', lw=0, shading='gouraud' # ,shading='flat' # ,vmin=vmin,vmax=vmax # ,cmap=blend_tripcolor_1_cmap , alpha=blend_tripcolor_1_alpha) # ,vmin=vmin,vmax=vmax,cmap=blend_tripcolor_1_cmap,alpha=blend_tripcolor_1_alpha) if goes_plot_1[iter]: if goes_plot_1_points[iter]: ax.scatter(glon, glat, s=8, c='black') if nodes_cover[iter] > 0: if nodes_cover[iter] == 1: cc_data_ = cover_cat.get_all_data('goes') else: cc_data_ = cover_cat.get_all_data('modis') sids_, dat_ = zip(*[cd.as_tuple() for cd in cc_data_]) # print('sids_ len: ',len(sids_)) sids_test = gd.spatial_clear_to_resolution( npi64([ gd.spatial_coerce_resolution(s, gm_cat_resolution) for s in sids_ ])) # print('sids_tlen: ',len(sids_test)) if cover_type == 'circular': print('cover: 0x%016x' % ps.from_latlon(npf64([cover_lat]), npf64( [cover_lon]), cover_resolution)[0]) geom_test = sid_geometry(sids_test) for s in geom_test.triangles.keys(): print(iter, ' 0x%016x' % s) triang_test = geom_test.triang() # ax.triplot(triang_test,'g-',transform=transf,lw=1.0,markersize=3,alpha=0.75) ax.triplot(triang_test, 'k-', transform=transf, lw=1.0, markersize=3, alpha=0.5) if False: for i in range(0, 10): k = cover_cat.sdict.peekitem(i)[0] triang = cover_cat.sdict[k].geometry.triang() ax.triplot(triang, 'b-', transform=transf, lw=1, markersize=3, alpha=0.5) if cover_plot[iter]: # lli = ps.triangulate_indices(ps.expand_intervals(cover,9,result_size_limit=2048)) lli = ps.triangulate_indices(cover) ax.triplot(tri.Triangulation(lli[0], lli[1], lli[2]), 'k-', transform=transf, lw=1, markersize=3, alpha=0.5) # ,'g-',transform=transf,lw=1,markersize=3) if False: # k = gm_catalog.sdict.keys()[0] # for k in gm_catalog.sdict.keys(): for i in range(0, 3): k = gm_catalog.sdict.peekitem(i)[0] triang = gm_catalog.sdict[k].geometry.triang() ax.triplot(triang, 'r-', transform=transf, lw=1, markersize=3) if circle_plot[iter]: phi = np.linspace(0, 2 * np.pi, 64) # rad=cover_rad rad = 0.125 ax.plot(cover_lon + rad * np.cos(phi), cover_lat + rad * np.sin(phi), transform=transf, color=circle_color[iter]) # ax.set_facecolor('k') if plt_show_1[iter]: plt.show() ########################################################################### # # if False: # sw_timer.stamp('triangulating') # print('triangulating') # client = Client() # for lli_ in slam(client,ps.triangulate_indices,sids): # sw_timer.stamp('slam iteration') # print('lli_ type: ',type(lli_)) # lli = lli_.result() # sw_timer.stamp('slam result') # print('lli type: ',type(lli)) # triang = tri.Triangulation(lli[0],lli[1],lli[2]) # sw_timer.stamp('slam triang') # plt.triplot(triang,'r-',transform=transf,lw=1.5,markersize=3,alpha=0.5) # sw_timer.stamp('slam triplot') # # sw_timer.stamp('plt show') # # lons,lats,intmat=ps.triangulate_indices(sids) # # triang = tri.Triangulation(lons,lats,intmat) # # plt.triplot(triang,'r-',transform=transf,lw=1.5,markersize=3) # # plt.show() # client.close() print(sw_timer.report_all())
def test_intersect_range_single_res(self): resolution = 6 resolution0 = resolution lat0 = numpy.array([10, 5, 60, 70], dtype=numpy.double) lon0 = numpy.array([-30, -20, 60, 10], dtype=numpy.double) hull0 = pystare.to_hull_range_from_latlon(lat0, lon0, resolution0) # print("len hull0: ",len(hull0)) resolution1 = 6 lat1 = numpy.array([10, 20, 30, 20], dtype=numpy.double) lon1 = numpy.array([-60, 60, 60, -60], dtype=numpy.double) hull1 = pystare.to_hull_range_from_latlon(lat1, lon1, resolution1) # print("len hull1: ",len(hull1)) r0 = pystare.srange() r0.add_intervals(hull0) r1 = pystare.srange() r1.add_intervals(hull1) r01 = pystare.srange() # print("0800") r01.add_intersect(r0, r1, False) r01.set_values_multi_resolution(False) # print("0900") n01 = r01.get_size_as_values() # print("1000") self.assertEqual(328, n01) intersected = numpy.zeros([n01], dtype=numpy.int64) r01.copy_values(intersected) # See examples/test_intersect_single_res.py self.assertEqual(328, len(intersected)) r01.purge() n01 = r01.get_size_as_values() self.assertEqual(0, n01) r01.reset() r01.add_intersect(r0, r1, True) r01.set_values_multi_resolution(True) # expand multi res # ?? Do we need a compress here? n01 = r01.get_size_as_values() # self.assertEqual(172, n01) # self.assertEqual(82, n01) self.assertEqual(79, n01) # with expandIntervalMultiRes fix intersected = numpy.zeros([n01], dtype=numpy.int64) intersected0 = numpy.zeros([n01], dtype=numpy.int64) # print('\nn01: ',n01) r01.copy_values(intersected) r01.copy_values(intersected0) # See examples/test_intersect_single_res.py # self.assertEqual(172, len(intersected)) # self.assertEqual(82, len(intersected)) self.assertEqual(79, n01) # with expandIntervalMultiRes fix iv = intersected[3] self.assertEqual(True, r01.contains(int(iv))) iv_max_plus = 4584664420663164934 + 100000000000000000 self.assertEqual(False, r01.contains(int(iv_max_plus))) for i in range(int(len(intersected))): if i % 2 == 0: intersected[int(i)] = int(4584664420663164934 + (100000000000000000 + 1000000 * i)) intersected1 = numpy.zeros(intersected.shape, dtype=numpy.int64) # test+ r0.compress() # test- r0.acontains(intersected, intersected1, -1) # An element in r01 should be in r0, yes? for i in range(len(intersected)): # print(i,'i',hex(intersected[i]),hex(intersected1[i])) # print('%3d = i, %016x, %016x, %016x'%(i,intersected[i],intersected1[i],intersected0[i])) if i % 2 == 0: self.assertEqual(-1, intersected1[i]) else: self.assertEqual(intersected[i], intersected1[i])
proj = ccrs.PlateCarree() # proj = ccrs.Mollweide() # proj = ccrs.Mollweide(central_longitude=-160.0) transf = ccrs.Geodetic() plt.figure() ax = plt.axes(projection=proj) ax.set_title('G-RING Test') ax.set_global() ax.coastlines() if True: plt.scatter(lon, lat, s=1, c=data, transform=transf) plt.triplot(triang, 'b-', transform=transf, lw=1, markersize=2) crop_lat = (27.0, 39.0) crop_lon = (-161.5, -159.5) crop_lats = np.array([crop_lat[0], crop_lat[0], crop_lat[1], crop_lat[1]], dtype=np.double) crop_lons = np.array([crop_lon[0], crop_lon[1], crop_lon[1], crop_lon[0]], dtype=np.double) ar_resolution = 7 ar_cover = ps.to_hull_range_from_latlon(crop_lats, crop_lons, ar_resolution) # print('ar_cover size: ',ar_cover.size) # ar_cover_mn = np.amin(ar_cover) # ar_cover_mx = np.amax(ar_cover) lons, lats, intmat = ps.triangulate_indices(ar_cover) triang = tri.Triangulation(lons, lats, intmat) plt.triplot(triang, 'r-', transform=transf, lw=1.5, markersize=3) plt.show()
def test_intersect_single_res(proj, transf): resolution = 6 resolution0 = resolution lat0 = numpy.array([10, 5, 60, 70], dtype=numpy.double) lon0 = numpy.array([-30, -20, 60, 10], dtype=numpy.double) hull0 = pystare.to_hull_range_from_latlon(lat0, lon0, resolution0) lons0, lats0, intmat0 = pystare.triangulate_indices(hull0) triang0 = tri.Triangulation(lons0, lats0, intmat0) resolution1 = 6 lat1 = numpy.array([10, 20, 30, 20], dtype=numpy.double) lon1 = numpy.array([-60, 60, 60, -60], dtype=numpy.double) hull1 = pystare.to_hull_range_from_latlon(lat1, lon1, resolution1) lons1, lats1, intmat1 = pystare.triangulate_indices(hull1) triang1 = tri.Triangulation(lons1, lats1, intmat1) #+ fig, axs = plt.subplots(3,subplot_kw={'projection':proj,'transform':transf}) fig, axs = plt.subplots(4, subplot_kw={ 'projection': proj, 'transform': transf }) # plt.figure() # plt.subplot(projection=proj,transform=transf) ax = axs[0] # ax.set_global() ax.coastlines() plot1(None, None, lons0, lats0, triang0, c0='r', c1='b', transf=transf, ax=ax) plot1(None, None, lons1, lats1, triang1, c0='c', c1='r', transf=transf, ax=ax) # plt.show() intersectedFalse = pystare.intersect(hull0, hull1, multiresolution=False) # print('intersectedFalse: ',intersectedFalse) intersectedTrue = pystare.intersect(hull0, hull1, multiresolution=True) # plt.figure() # plt.subplot(projection=proj,transform=transf) ax = axs[1] # ax.set_global() ax.coastlines() lonsF, latsF, intmatF = pystare.triangulate_indices(intersectedFalse) triangF = tri.Triangulation(lonsF, latsF, intmatF) plot1(None, None, lonsF, latsF, triangF, c0='r', c1='b', transf=transf, ax=ax) # plt.show() # plt.figure() # plt.subplot(projection=proj,transform=transf) ax = axs[2] # ax.set_global() ax.coastlines() lonsT, latsT, intmatT = pystare.triangulate_indices(intersectedTrue) triangT = tri.Triangulation(lonsT, latsT, intmatT) plot1(None, None, lonsT, latsT, triangT, c0='r', c1='b', transf=transf, ax=ax) # plt.show() ## ok ## print(' len(False),len(True),delta: ',len(intersectedFalse),len(intersectedTrue),len(intersectedTrue)-len(intersectedFalse)) ## ok ## print('un len(False),len(True),delta: ',len(numpy.unique(intersectedFalse)),len(numpy.unique(intersectedTrue)),len(numpy.unique(intersectedTrue))-len(numpy.unique(intersectedFalse))) ## ok ## print('compressed==True, first total, then w/o double counting: ',(7*16)+(17*4),(7*16)+(17*4)-(7+17)) # print('count 0: ',sum([1,34,34,4*6,24,22,9])) if True: r0 = pystare.srange() r0.add_intervals(hull0) r1 = pystare.srange() r1.add_intervals(hull1) r01 = pystare.srange() r01.add_intersect(r0, r1, False) n01 = r01.get_size_as_values() # self.assertEqual(328, n01) intersected = numpy.zeros([n01], dtype=numpy.int64) r01.copy_values(intersected) # See examples/test_intersect_single_res.py # self.assertEqual(328, len(intersected)) r01.purge() n01 = r01.get_size_as_values() # self.assertEqual(0, n01) r01.reset() r01.add_intersect(r0, r1, True) # n01 = r01.get_size_as_values() # n01 = r01.get_size_as_values_multi_resolution(False) n01 = r01.get_size_as_values() #? self.assertEqual(172, n01) # self.assertEqual(82, n01) print('r01 n01: ', n01) intersected = numpy.zeros([n01], dtype=numpy.int64) r01.copy_values(intersected) ###??? Would intervals be different? lonsRT, latsRT, intmatRT = pystare.triangulate_indices(intersected) triangRT = tri.Triangulation(lonsRT, latsRT, intmatRT) # fig, axs = plt.subplots(3,subplot_kw={'projection':proj,'transform':transf}) # plt.figure() # plt.subplot(projection=proj,transform=transf) ax = axs[3] # ax.set_global() ax.coastlines() # plot1(None,None,lonsRT,latsRT,triangRT,c0='r',c1='b',transf=transf,ax=ax) lonsRT_, latsRT_, intmatRT_ = pystare.triangulate_indices( intersected[51:55]) triangRT_ = tri.Triangulation(lonsRT_, latsRT_, intmatRT_) # k = 51 # for j in intersected[51:55]: # print(k,' siv: 0x%016x'%intersected[k]) # k += 1 plot1(None, None, lonsRT_, latsRT_, triangRT_, c0='g', c1='g', transf=transf, ax=ax) print('len(intersected): ', len(intersected)) plt.show()
def make_hull(lat0, lon0, resolution0): hull0 = ps.to_hull_range_from_latlon(lat0, lon0, resolution0) lath0, lonh0, lathc0, lonhc0 = ps.to_vertices_latlon(hull0) lons0, lats0, intmat0 = ps.triangulate(lath0, lonh0) triang0 = tri.Triangulation(lons0, lats0, intmat0) return lats0, lons0, triang0, hull0
def plot1(triang): # plt.triplot(triang,'ro-',transform=ccrs.Geodetic()) plt.triplot(triang,'r-',transform=transf) # plt.show() return test1_lons,test1_lats,test1_intmat = test1(indices) plot1(tri.Triangulation(test1_lons,test1_lats,test1_intmat)) plt.scatter(test1_lons,test1_lats,s=5,c='r',transform=ccrs.PlateCarree()) # resolution = 2; resolution = 4; # resolution = 7; # hull = ps.to_hull_range(indices,resolution,100) hull = ps.to_hull_range_from_latlon(lat,lon,resolution) print('0 hull len: ',len(hull)) # print(90) # lats0 = np.zeros(len(hull)*4,dtype=np.int64) # lons0 = np.zeros(len(hull)*4,dtype=np.int64) # lats0,lons0 = ps._to_vertices_latlon(hull) # print('lats0,lons0: ',len(lats0),len(lons0)) # print(100) lath,lonh,lathc,lonhc = ps.to_vertices_latlon(hull) print('lath,lathc: ',len(lath),len(lathc)) # print(110) lons1,lats1,intmat1 = triangulate1(lath,lonh) ## h0,h1,h2,hc = ps.to_vertices(hull) ## lons1,lats1,intmat1 = triangulate(h0,h1,h2)