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)
