def add(self, sids):
for sid in sids:
if sid not in self.triangles.keys():
self.tri_triang = None
self.triangles[sid] = ps.triangulate_indices(
np.array([sid], dtype=np.int64)) ## LLI
return
def plot_sivs(sivs, c0='r', c1='b', transf=None, lw=1, ax=None):
lons0, lats0, intmat0 = ps.triangulate_indices(sivs)
triang0 = tri.Triangulation(lons0, lats0, intmat0)
plot1(None,
None,
lons0,
lats0,
triang0,
c0=c0,
c1=c1,
transf=transf,
ax=ax)
return
def main():
# proj = ccrs.PlateCarree()
proj = ccrs.Mollweide()
transf = ccrs.Geodetic()
plt.figure()
ax = plt.axes(projection=proj)
# ax.set_xlim(-180,180)
# ax.set_ylim(-90,90)
ax.stock_img()
ax.coastlines()
ax.gridlines()
lats = np.array([-45,-45,-45,-45,-45, -45, 45,45,45, 45, 45, 45],dtype=np.double)
lons = np.array([ 0, 45, 90,135,180, 225, 0,45,90,135,180,225],dtype=np.double)
tmp_cover = ps.from_latlon(lats,lons,0)
print('tmp_cover len: ',len(tmp_cover))
print('tmp_cover: ',tmp_cover)
clons,clats,cintmat = ps.triangulate_indices(tmp_cover)
ctriang = tri.Triangulation(clons,clats,cintmat)
ax.triplot(ctriang,'b-',transform=transf,lw=1.0,markersize=3,alpha=1.0)
zlatv = np.array([
0, 90, 0, 0, 90, 0, 0, 90, 0, 0, 90, 0,
0,-90, 0, 0, -90, 0, 0, -90, 0, 0, -90, 0
],dtype=np.double)
zlonv = np.array([
0,90,90, 90, 90, 180, 180, 270, 270, 270, 360, 360,
0,90,90, 90, 90, 180, 180, 270, 270, 270, 360, 360
],dtype=np.double)
zlons,zlats,zintmat = gd.triangulate1(zlatv,zlonv)
ztriang = tri.Triangulation(zlons,zlats,zintmat)
ax.triplot(ztriang,'r-',transform=transf,lw=1.0,markersize=3,alpha=1.0)
an = ax.annotate(
'Figure: sketchM0\n'
+'Date: %s\n'%datetime.date.today()
+'Version: 2020-0407-1\n'
+'Author: M. Rilee, RSTLLC\n'
+'Email: [email protected]\n'
,xy=(0.7,0.025)
,xycoords='figure fraction'
,family='monospace'
)
plt.show()
return
def plot2(sids, c0='r', c1='g', transf=None, ax=None):
lons, lats, intmat = pystare.triangulate_indices(sids)
triang = tri.Triangulation(lons, lats, intmat)
plot1(None,
None,
lons=lons,
lats=lats,
triang=triang,
c0=c0,
c1=c1,
transf=transf,
lw=1,
ax=ax)
return
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
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
###########################################################################
# MODIS HDF
hdf = SD(dataPath+modis_filename,SDC.READ)
# ds_wv_nir = hdf.select('Water_Vapor_Near_Infrared')
modis_hdf_resolution = 7
ntri_max = 1000
# hull = ps.to_hull_range_from_latlon(gring_lat[gring_seq],gring_lon[gring_seq],resolution,ntri_max)
modis_hdf_hull = gd.modis_cover_from_gring(hdf,modis_hdf_resolution,ntri_max)
hdf.end()
modis_hdf_lons,modis_hdf_lats,modis_hdf_intmat = ps.triangulate_indices(modis_hdf_hull)
modis_hdf_triang = tri.Triangulation(modis_hdf_lons,modis_hdf_lats,modis_hdf_intmat)
###########################################################################
# 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
goes_sids_005 = np.unique(gd.spatial_clear_to_resolution((goes_sids[np.where(goes_sids>0)] & ~31)+5))
goes_sids_005_geom = sid_geometry(goes_sids_005)
goes_sids_005_triang = goes_sids_005_geom.triang()
###########################################################################
# Plotting an ROI
cover_rads =[2.0,0,0, 0.125,0,0]
circle_color=[ 'Lime' ,'lightgrey' ,'White' ,'navajowhite' ,'khaki' ,'White' ]
###########################################################################
# HI 28.5N 177W
cover_resolution = 11
cover_lat = 19.5-0.375
cover_lon = -155.5+0.375
###########################################################################
# Plotting
nrows = 1
ncols = 1
# proj = ccrs.PlateCarree()
proj = ccrs.PlateCarree(central_longitude=-160.0)
# proj = ccrs.Mollweide()
# proj = ccrs.Mollweide(central_longitude=-160.0)
transf = ccrs.Geodetic()
fig,axs = plt.subplots(nrows=nrows,ncols=ncols,subplot_kw={'projection': proj})
subplot_title = ['GOES and MODIS Granules']
ax = axs
distribute_to_nodes = False
if True:
iter = 0
ax.set_xlim(-160-45,160+45)
if subplot_title[iter] is not None:
ax.set_title(subplot_title[iter])
if False:
ax.set_global()
if True:
ax.coastlines()
if distribute_to_nodes:
vmin=0; vmax=16
# colors=np.arange(goes_sids_005_triang.x.shape[0]/3,dtype=np.int64)%(vmax-vmin)
colors=np.random.uniform(vmin,vmax,size=int(goes_sids_005_triang.x.shape[0]/3)).astype(np.int64)
ax.tripcolor(goes_sids_005_triang
,facecolors=colors
,edgecolors='k',lw=0
,shading='flat'
,vmin=vmin,vmax=vmax,cmap='rainbow',alpha=0.65
,transform=transf)
ax.triplot(goes_sids_005_triang ,'r-',transform=transf,lw=1.0,markersize=3,alpha=0.5)
ax.triplot(modis_hdf_triang ,'b-',transform=transf,lw=1.0,markersize=3,alpha=0.5)
if True:
phi=np.linspace(0,2*np.pi,64)
cover_rad = cover_rads[iter]
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],lw=2)
if iter == 0:
x0 = 0.05
y0 = 0.025; dy = 0.025
plt.figtext(x0,y0+0*dy
,"MODIS (blue): "+"sketchG."+modis_base+modis_item+fmt_suffix+', cover from GRING metadata, max resolution = 7'
,fontsize=10)
k=0;
while goes_sids[k]<0:
k=k+1
plt.figtext(x0,y0+1*dy
,"GOES (red): "+goes_file+', Northern Hemisphere, resolution = 5'
,fontsize=10)
plt.figtext(x0,y0+2*dy
,"Region of Interest near Hawaii, ROI (%s): radius = %0.2f degrees, center = 0x%016x"%(circle_color[iter],cover_rads[0],ps.from_latlon(npf64([cover_lat]),npf64([cover_lon]),cover_resolution)[0])
,fontsize=10)
if distribute_to_nodes:
plt.figtext(x0,y0+3*dy
,"Color tiles show distribution across 16 nodes."
,fontsize=10)
plt.show()
def __init__(self,
siv=None,
tiv=None,
tiv_representation=None,
tiv_scale=None,
tiv_offset=None,
color_reverse=None,
color=None,
color_forward=None,
tiv_mock=None):
self.siv = (None if siv is None else siv)
self.tiv = None if tiv is None else tiv
self.tiv_mock = ([0.0, 0.33, 0.67, 1.0]
if tiv_mock is True else tiv_mock)
tiv_scale = 1 if tiv_scale is None else tiv_scale # Scale to a day
tiv_offset = 0 if tiv_offset is None else tiv_offset # In days, by default
tiv_representation = 'tai' if tiv_representation is None else tiv_representation
if tiv_representation not in ['ms', 'tai', 'ms-utc']:
raise ValueError(
"tiv_representation not 'ms', 'tai', nor 'ms-utc'.")
if tiv_mock is not None:
self.tiv_plot = self.tiv_mock
else:
if type(self.tiv) != numpy.ndarray:
self.tiv = numpy.array([self.tiv], dtype=numpy.int64)
if tiv_representation == 'tai':
triple = numpy.concatenate(
pystare.to_temporal_triple_tai(self.tiv))
# print(triple)
# print(type(triple))
t_triple = pystare.to_JulianTAI(triple)
elif tiv_representation == 'ms':
triple = numpy.concatenate(
pystare.to_temporal_triple_ms(self.tiv))
t_triple = pystare.to_JulianTAI(triple)
else: # 'ms-utc'
triple = numpy.concatenate(
pystare.to_temporal_triple_ms(self.tiv))
t_triple = pystare.to_JulianUTC(triple)
self.t_lo = (t_triple[0][0] +
t_triple[1][0]) / tiv_scale + tiv_offset
self.t_mi = (t_triple[0][1] +
t_triple[1][1]) / tiv_scale + tiv_offset
self.t_hi = (t_triple[0][2] +
t_triple[1][2]) / tiv_scale + tiv_offset
alpha = 0.25
dtlo = self.t_mi - self.t_lo
dthi = self.t_hi - self.t_mi
self.tiv_plot = [
self.t_lo, self.t_mi - alpha * dtlo, self.t_mi + alpha * dthi,
self.t_hi
]
self.lons, self.lats, self.intmat = pystare.triangulate_indices(
[self.siv])
if color_reverse is None and color is None and color_forward is None:
self.color_reverse = 'red'
self.color = 'green'
self.color_forward = 'blue'
elif color is not None:
self.color_reverse = (color
if color_reverse is None else color_reverse)
self.color = color
self.color_forward = (color
if color_forward is None else color_forward)
else:
self.color_reverse = ('red'
if color_reverse is None else color_reverse)
self.color = 'green'
self.color_forward = ('blue'
if color_forward is None else color_forward)
return
def main():
print('MODIS Sketching')
data_sourcedir = '/home/mrilee/data/MODIS/'
# Geolocation files
mod03_catalog = gd.data_catalog({
'directory': data_sourcedir,
'patterns': ['MOD03*']
})
# Data files
mod05_catalog = gd.data_catalog({
'directory': data_sourcedir,
'patterns': ['MOD05*']
})
print('mod03 catalog\n', mod03_catalog.get_files())
print('mod03 catalog\n', mod03_catalog.get_tid_centered_index())
print('mod05 catalog\n', mod05_catalog.get_tid_centered_index())
modis_sets = SortedDict()
tKeys = list(mod05_catalog.tid_centered_index.keys())
for tid in tKeys:
# for tid in tKeys[0:1]:
# for tid in mod05_catalog.tid_centered_index: # replace with temporal comparison
if (len(mod05_catalog.tid_centered_index[tid]) > 1
or len(mod03_catalog.tid_centered_index[tid]) > 1):
raise NotImplementedError(
'sketchH only written for preselected pairs of MODIS files')
modis_sets[tid] = modis05_set(mod05_catalog.tid_centered_index[tid][0],
mod03_catalog.tid_centered_index[tid][0],
data_sourcedir=data_sourcedir)
modis_sets[tid].load_wv_nir().load_geo().make_sare()
# print(hex(tid),modis_sets[tid].data,modis_sets[tid].location)
# print(modis_sets[tid].info())
###########################################################################
proj = ccrs.PlateCarree()
transf = ccrs.Geodetic()
def init_figure(proj):
plt.figure()
ax = plt.axes(projection=proj)
# ax.set_global()
# ax.coastlines()
return ax
vmin = np.amin(np.array([a.vmin() for a in modis_sets.values()]))
vmax = np.amax(np.array([a.vmax() for a in modis_sets.values()]))
tKeys = list(modis_sets.keys())
tKeys = [tKeys[1]]
# tid = tKeys[0]
# tKeys = tKeys[1:]
# tKeys = tKeys[-2:-1]
# for tid in mod05_catalog.tid_centered_index: # replace with temporal comparison
# if True:
for tid in tKeys:
if False:
plt.scatter(modis_sets[tid].geo_lon,
modis_sets[tid].geo_lat,
s=1,
c=modis_sets[tid].data_wv_nir,
transform=transf,
vmin=vmin,
vmax=vmax)
tmp_data_src_name = mod05_catalog.tid_centered_index[tid][0][0:-4]
# print('tmp_data_src_name: ',tmp_data_src_name)
# clons,clats,cintmat = ps.triangulate_indices(modis_sets[tid].cover)
tmp_cover = ps.to_compressed_range(modis_sets[tid].cover)
# tmp_cover = ps.expand_intervals(tmp_cover,2)
tmp_cover = ps.expand_intervals(tmp_cover, 4)
# tmp_cover = ps.expand_intervals(tmp_cover,6,result_size_limit=1600)
if False:
clons, clats, cintmat = ps.triangulate_indices(tmp_cover)
ctriang = tri.Triangulation(clons, clats, cintmat)
spart_nmax = -1
# tmp_cover = tmp_cover[0:10]
idx_all = {}
for sid in tmp_cover:
# print(sid,' sid, indexing cover sid: 0x%016x'%sid)
idx_all[sid] = np.where(
ps.cmp_spatial(np.array([sid], dtype=np.int64),
modis_sets[tid].sare) != 0)
spart_nmax = max(spart_nmax,
len(modis_sets[tid].sare[idx_all[sid]]))
# print('max spart items to write per file: ',spart_nmax)
spart_nmax = None # Variable lengths
spart_names = []
for sid in tmp_cover:
idx = idx_all[sid][0]
# print(sid,' sid,cover sid: 0x%016x'%sid,' len(idx)=%i'%(len(idx)))
# print('idx: ',idx)
# print('idx type: ',type(idx))
spart_h5_namebase = 't%016x.%s' % (tid,
tmp_data_src_name + '.sketchJ0')
# MAKE
spart_h5 = sare_partition(sid,
spart_h5_namebase,
src_name=tmp_data_src_name,
var_nmax=spart_nmax)
# CHECK
# print(' data_wv_nir mn,mx: ',np.amin(modis_sets[tid].data_wv_nir),np.amax(modis_sets[tid].data_wv_nir))
# WRITE
if True:
spart_h5.write1(
shape=[modis_sets[tid].nAcross, modis_sets[tid].nAlong],
dataset_name='wv_nir',
vars={
'sare':
modis_sets[tid].sare[idx],
'src_coord':
np.arange(len(modis_sets[tid].sare))[idx],
'Water_Vapor_Near_Infrared':
modis_sets[tid].data_wv_nir.flatten()[idx]
})
# print('')
spart_names.append(spart_h5.fname)
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'b-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
plt.scatter(modis_sets[tid].geo_lon.flatten()[idx],
modis_sets[tid].geo_lat.flatten()[idx],
s=1,
c=modis_sets[tid].data_wv_nir.flatten()[idx],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
# READ
spart_h5_1 = sare_partition(sid, spart_h5_namebase)
(s5_shape, s5_name, s5_vars, s5_vars_dtype,
s5_metadata_dtype) = spart_h5_1.read1()
# print('found and loaded %s of type %s.'%(s5_name,s5_vars_dtype))
idx = s5_vars['src_coord']
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'g-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
plt.scatter(modis_sets[tid].geo_lon.flatten()[idx],
modis_sets[tid].geo_lat.flatten()[idx],
s=1,
c=modis_sets[tid].data_wv_nir.flatten()[idx],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'r-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
lat, lon = ps.to_latlon(s5_vars['sare'])
plt.scatter(lon,
lat,
s=1,
c=s5_vars['Water_Vapor_Near_Infrared'],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
####
## # Define the layout of the virtual data set.
## var_ns = [len(idx_all[i][0]) for i in idx_all]
## var_n_cumul = [0]
## for i in range(len(idx_all)):
## var_n_cumul.append(var_n_cumul[-1]+var_ns[i])
## # var_n_total = sum([len(i) for i in idx_all])
## var_n_total = var_n_cumul[-1]
##
## print('')
## print('var_ns: ',var_ns)
## print('var_n_cumul: ',var_n_cumul)
## print('var_n_total: ',var_n_total)
##
## layout = h5.VirtualLayout(shape=(var_n_total,),dtype=s5_vars_dtype)
## print('layout: ',layout)
##
## layout_md = h5.VirtualLayout(shape=(len(spart_names),),dtype=s5_metadata_dtype)
## print('layout_md: ',layout_md)
## print('')
##
## layout_idx = np.arange(var_n_total)
##
## for i in range(len(spart_names)):
## print(i,' part: ',var_n_cumul[i],var_n_cumul[i+1],', ',var_ns[i])
## print('')
##
## # print('s5_metadata_dtype: ',s5_metadata_dtype)
## ds_name = 'wv_nir'
## for i in range(len(spart_names)):
## # Just concatenate
## #++ layout[var_n_cumul[i]:var_n_cumul[i+1]] = h5.VirtualSource(spart_names[i],ds_name,shape=(var_ns[i],))
## # What I would like to do...
## if var_ns[i] != 0:
## with h5.File(spart_names[i]) as h:
## vs = h5.VirtualSource(spart_names[i],ds_name,shape=(var_ns[i],))
## for j in range(h[ds_name]['src_coord'].shape[0]): # Should be var_ns[i]
## layout[h[ds_name]['src_coord'][j]] = vs[j] # next step, try [j,k] for a virtual image....
## # else: # zero-case
## # layout[var_n_cumul[i]:var_n_cumul[i+1]] = h5.VirtualSource(spart_names[i],ds_name,shape=(var_ns[i],))
##
## for i in range(len(spart_names)):
## layout_md[i] = h5.VirtualSource(spart_names[i],'metadata',shape=(1,))
##
## vds_fname = '.'.join([tmp_data_src_name,ds_name,'sketchJ0.vds.h5'])
## print('writing ',vds_fname)
## with h5.File(vds_fname,'w',libver='latest') as f:
## f.create_virtual_dataset('wv_nir',layout) # fillvalue?
## f.create_virtual_dataset('metadata',layout_md) # fillvalue?
## # f.create_dataset(['image_lookup']...)
print('MODIS Sketching Done')
return
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 main():
print('MODIS Sketching')
data_sourcedir = '/home/mrilee/data/MODIS/'
# Geolocation files
mod03_catalog = gd.data_catalog({
'directory': data_sourcedir,
'patterns': ['MOD03*']
})
# Data files
mod05_catalog = gd.data_catalog({
'directory': data_sourcedir,
'patterns': ['MOD05*']
})
print('mod03 catalog\n', mod03_catalog.get_files())
print('mod03 catalog\n', mod03_catalog.get_tid_centered_index())
print('mod05 catalog\n', mod05_catalog.get_tid_centered_index())
modis_sets = SortedDict()
tKeys = list(mod05_catalog.tid_centered_index.keys())
for tid in tKeys:
# for tid in tKeys[0:1]:
# for tid in mod05_catalog.tid_centered_index: # replace with temporal comparison
if (len(mod05_catalog.tid_centered_index[tid]) > 1
or len(mod03_catalog.tid_centered_index[tid]) > 1):
raise NotImplementedError(
'sketchH only written for preselected pairs of MODIS files')
modis_sets[tid] = modis05_set(mod05_catalog.tid_centered_index[tid][0],
mod03_catalog.tid_centered_index[tid][0],
data_sourcedir=data_sourcedir)
modis_sets[tid].load_wv_nir().load_geo().make_sare()
# print(hex(tid),modis_sets[tid].data,modis_sets[tid].location)
# print(modis_sets[tid].info())
###########################################################################
proj = ccrs.PlateCarree()
transf = ccrs.Geodetic()
def init_figure(proj):
plt.figure()
ax = plt.axes(projection=proj)
# ax.set_global()
# ax.coastlines()
return ax
vmin = np.amin(np.array([a.vmin() for a in modis_sets.values()]))
vmax = np.amax(np.array([a.vmax() for a in modis_sets.values()]))
tKeys = list(modis_sets.keys())
tid = tKeys[0]
# tKeys = tKeys[1:]
# tKeys = tKeys[-2:-1]
# for tid in mod05_catalog.tid_centered_index: # replace with temporal comparison
# if True:
for tid in tKeys:
if False:
plt.scatter(modis_sets[tid].geo_lon,
modis_sets[tid].geo_lat,
s=1,
c=modis_sets[tid].data_wv_nir,
transform=transf,
vmin=vmin,
vmax=vmax)
tmp_data_src_name = mod05_catalog.tid_centered_index[tid][0][0:-4]
# print('tmp_data_src_name: ',tmp_data_src_name)
# clons,clats,cintmat = ps.triangulate_indices(modis_sets[tid].cover)
tmp_cover = ps.to_compressed_range(modis_sets[tid].cover)
# tmp_cover = ps.expand_intervals(tmp_cover,2)
tmp_cover = ps.expand_intervals(tmp_cover, 5)
clons, clats, cintmat = ps.triangulate_indices(tmp_cover)
ctriang = tri.Triangulation(clons, clats, cintmat)
spart_nmax = -1
# tmp_cover = tmp_cover[0:10]
idx_all = {}
for sid in tmp_cover:
# print(sid,' sid, indexing cover sid: 0x%016x'%sid)
idx_all[sid] = np.where(
ps.cmp_spatial(np.array([sid], dtype=np.int64),
modis_sets[tid].sare) != 0)
spart_nmax = max(spart_nmax,
len(modis_sets[tid].sare[idx_all[sid]]))
# print('max spart items to write per file: ',spart_nmax)
spart_names = []
for sid in tmp_cover:
idx = idx_all[sid][0]
# print(sid,' sid,cover sid: 0x%016x'%sid,' len(idx)=%i'%(len(idx)))
# print('idx: ',idx)
# print('idx type: ',type(idx))
spart_h5_namebase = 't%016x.%s' % (tid,
tmp_data_src_name + '.sketchH')
spart_h5 = sare_partition(sid,
spart_h5_namebase,
src_name=tmp_data_src_name,
var_nmax=spart_nmax)
spart_h5.write1(
shape=[modis_sets[tid].nAcross, modis_sets[tid].nAlong],
dataset_name='wv_nir',
vars={
'sare':
modis_sets[tid].sare[idx],
'src_coord':
np.arange(len(modis_sets[tid].sare))[idx],
'Water_Vapor_Near_Infrared':
modis_sets[tid].data_wv_nir.flatten()[idx]
})
spart_names.append(spart_h5.fname)
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'b-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
plt.scatter(modis_sets[tid].geo_lon.flatten()[idx],
modis_sets[tid].geo_lat.flatten()[idx],
s=1,
c=modis_sets[tid].data_wv_nir.flatten()[idx],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
spart_h5_1 = sare_partition(sid, spart_h5_namebase)
(s5_shape, s5_name, s5_vars, s5_vars_dtype,
s5_metadata_dtype) = spart_h5_1.read1()
# print('found and loaded %s of type %s.'%(s5_name,s5_vars_dtype))
idx = s5_vars['src_coord']
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'g-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
plt.scatter(modis_sets[tid].geo_lon.flatten()[idx],
modis_sets[tid].geo_lat.flatten()[idx],
s=1,
c=modis_sets[tid].data_wv_nir.flatten()[idx],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
if False:
ax = init_figure(proj)
ax.triplot(ctriang,
'r-',
transform=transf,
lw=1.0,
markersize=3,
alpha=0.5)
lat, lon = ps.to_latlon(s5_vars['sare'])
plt.scatter(lon,
lat,
s=1,
c=s5_vars['Water_Vapor_Near_Infrared'],
transform=transf,
vmin=vmin,
vmax=vmax)
plt.show()
####
layout = h5.VirtualLayout(shape=(len(spart_names), spart_nmax),
dtype=s5_vars_dtype)
layout_md = h5.VirtualLayout(shape=(len(spart_names), 1),
dtype=s5_metadata_dtype)
# print('s5_metadata_dtype: ',s5_metadata_dtype)
ds_name = 'wv_nir'
for i in range(len(spart_names)):
layout[i] = h5.VirtualSource(spart_names[i],
ds_name,
shape=(spart_nmax, ))
layout_md[i] = h5.VirtualSource(spart_names[i],
'metadata',
shape=(1, ))
vds_fname = '.'.join([tmp_data_src_name, ds_name, 'vds.h5'])
print('writing ', vds_fname)
with h5.File(vds_fname, 'w', libver='latest') as f:
f.create_virtual_dataset('wv_nir', layout) # fillvalue?
f.create_virtual_dataset('metadata', layout_md) # fillvalue?
print('MODIS Sketching Done')
return
## ok ## # print(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLONGITUDE']['VALUE'])[:])
## ok ## # print(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLATITUDE']['VALUE'])[:])
## ok ## # print(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTSEQUENCENO']['VALUE'])[:])
## ok ## # hdf.end()
## ok ##
## ok ## gring_seq=np.array(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTSEQUENCENO']['VALUE'])[:],dtype=np.int)-1
## ok ## gring_lon=np.array(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLONGITUDE']['VALUE'])[:],dtype=np.double)
## ok ## gring_lat=np.array(eval(metadata_parsed['ARCHIVEDMETADATA']['GPOLYGON']['GPOLYGONCONTAINER']['GRINGPOINT']['GRINGPOINTLATITUDE']['VALUE'])[:],dtype=np.double)
## ok ##
resolution = 7
ntri_max = 1000
# hull = ps.to_hull_range_from_latlon(gring_lat[gring_seq],gring_lon[gring_seq],resolution,ntri_max)
hull = gd.modis_cover_from_gring(hdf, resolution, ntri_max)
hdf.end()
lons, lats, intmat = ps.triangulate_indices(hull)
triang = tri.Triangulation(lons, lats, intmat)
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)
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()
