def write_grd_file(data, atr, fname_out=None):
"""Write GMT .grd file for input data matrix, using giant._gmt module.
Inputs:
data - 2D np.array in int/float, data matrix to write
atr - dict, attributes of input data matrix
fname_out - string, output file name
Output:
fname_out - string, output file name
"""
if not fname_out:
fname_out = '{}.grd'.format(
pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps)))
# Get 1D array of lats and lons
lats, lons = get_geo_lat_lon(atr)
# writing
print('writing >>> ' + fname_out)
write_gmt_simple(lons,
np.flipud(lats),
np.flipud(data),
fname_out,
title='default',
name=atr['FILE_TYPE'],
scale=1.0,
offset=0,
units=atr['UNIT'])
return fname_out
def main(iargs=None):
inps = cmd_line_parse(iargs)
plt.switch_backend('Agg') # Backend setting
# Read data
k = readfile.read_attribute(inps.file)['FILE_TYPE']
if k == 'timeseries' and inps.dset and '_' in inps.dset:
inps.ref_date, inps.dset = inps.dset.split('_')
else:
inps.ref_date = None
data, atr = readfile.read(inps.file, datasetName=inps.dset)
if k == 'timeseries' and inps.ref_date:
data -= readfile.read(inps.file, datasetName=inps.ref_date)[0]
# mask
mask = pp.read_mask(inps.file,
mask_file=inps.mask_file,
datasetName=inps.dset,
print_msg=True)[0]
if mask is not None:
data = np.ma.masked_where(mask == 0., data)
if inps.zero_mask:
print('masking pixels with zero value')
data = np.ma.masked_where(data == 0., data)
# Data Operation - Display Unit & Rewrapping
(data, inps.disp_unit, inps.disp_scale,
inps.wrap) = pp.scale_data4disp_unit_and_rewrap(
data,
metadata=atr,
disp_unit=inps.disp_unit,
wrap=inps.wrap,
wrap_range=inps.wrap_range)
if inps.wrap:
inps.vlim = inps.wrap_range
# Output filename
inps.fig_title = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
if not inps.outfile:
inps.outfile = '{}.kmz'.format(inps.fig_title)
inps.outfile = os.path.abspath(inps.outfile)
# 2. Generate Google Earth KMZ
write_kmz_file(data, metadata=atr, out_file=inps.outfile, inps=inps)
return inps.outfile
def main(iargs=None):
inps = cmd_line_parse(iargs)
# Read data
data, atr = readfile.read(inps.file, datasetName=inps.dset)
# 2. Write GMT .grd file
if not inps.outfile:
outbase = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
inps.outfile = '{}.grd'.format(outbase)
inps.outfile = write_grd_file(data, atr, inps.outfile)
print('Done.')
return inps.outfile
def generate_network_link(inps, ts_obj, box_list, step, lod, output_file=None):
out_name_base = plot.auto_figure_title(inps.ts_file, inps_dict=vars(inps))
if output_file is None:
output_file = "{0}_{1}by{1}.kml".format(out_name_base, step)
nwklink_name = "{0} by {0}".format(step)
regions, dot_file, dygraph_file = create_kml_document(inps, box_list, ts_obj, step)
kml_file, kml_data_files_directory = create_regionalized_networklinks_file(regions, ts_obj, box_list, lod, step, output_file)
network_link = create_network_link_element(nwklink_name, kml_file, ts_obj)
cmdMove = "mv {0} {1}/{0}".format(output_file, kml_data_files_directory)
print("Moving KML Data Files to directory")
os.system(cmdMove)
return network_link, dot_file, dygraph_file, kml_data_files_directory
def main(iargs=None):
inps = cmd_line_parse(iargs)
# check reference date
print('read metadata from file: {}'.format(inps.file))
attr = readfile.read_attribute(inps.file)
if attr['FILE_TYPE'] == 'timeseries' and inps.dset and '_' in inps.dset:
inps.ref_date, inps.dset = inps.dset.split('_')
else:
inps.ref_date = None
# read data
print('read data from file: {}'.format(inps.file))
array, attr = readfile.read(inps.file, datasetName=inps.dset)
if attr['FILE_TYPE'] == 'timeseries' and inps.ref_date:
array -= readfile.read(inps.file, datasetName=inps.ref_date)[0]
# output filename
if not inps.outfile:
fbase = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
inps.outfile = fbase + GDAL_DRIVER2EXT.get(inps.out_format, '')
else:
inps.outfile = os.path.abspath(inps.outfile)
# coordinate info
rasterOrigin = (float(attr['X_FIRST']), float(attr['Y_FIRST']))
xStep = float(attr['X_STEP'])
yStep = float(attr['Y_STEP'])
kwargs = dict(xStep=xStep, yStep=yStep)
epsg = attr.get('EPSG', None)
if not epsg and 'UTM_ZONE' in attr.keys():
epsg = ut.utm_zone2epsg_code(attr['UTM_ZONE'])
if epsg:
kwargs['epsg'] = int(epsg)
# convert array to raster
array2raster(array, inps.outfile, inps.out_format, rasterOrigin, **kwargs)
return
def generate_cbar_element(inps):
out_name_base = plot.auto_figure_title(inps.ts_file, inps_dict=vars(inps))
cbar_png_file = '{}_cbar.png'.format(out_name_base)
cbar_png_file = plot_colorbar(out_file=cbar_png_file, vmin=inps.vlim[0], vmax=inps.vlim[1], cmap=inps.colormap)
cbar_overlay = KML.ScreenOverlay(
KML.name('Colorbar'),
KML.Icon(
KML.href("{}".format(cbar_png_file)),
KML.viewBoundScale(0.75)
),
KML.overlayXY(x="0", y="0", xunits="fraction", yunits="fraction"),
KML.screenXY(x="0", y="0", xunits="fraction", yunits="fraction"),
KML.size(x="0", y="250", xunits="pixel", yunits="pixel"),
KML.rotation(0),
KML.visibility(1),
KML.open(0)
)
print('add colorbar.')
return cbar_overlay, cbar_png_file
def main(iargs=None):
inps = cmd_line_parse(iargs)
plt.switch_backend('Agg') # Backend setting
# Read data
data, atr = readfile.read(inps.file, datasetName=inps.dset)
# mask
mask = pp.read_mask(inps.file, mask_file=inps.mask_file, datasetName=inps.dset, print_msg=True)[0]
if mask is not None:
data = np.ma.masked_where(mask == 0., data)
# Data Operation - Display Unit & Rewrapping
(data,
inps.disp_unit,
inps.disp_scale,
inps.wrap) = pp.scale_data4disp_unit_and_rewrap(data,
metadata=atr,
disp_unit=inps.disp_unit,
wrap=inps.wrap,
wrap_range=inps.wrap_range)
if inps.wrap:
inps.vlim = inps.wrap_range
# Output filename
inps.fig_title = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
if not inps.outfile:
inps.outfile = '{}.kmz'.format(inps.fig_title)
inps.outfile = os.path.abspath(inps.outfile)
# 2. Generate Google Earth KMZ
write_kmz_file(data,
metadata=atr,
out_file=inps.outfile,
inps=inps)
return inps.outfile
def main(iargs=None):
inps = cmd_line_parse(iargs)
# check reference date
print('read metadata from file: {}'.format(inps.file))
attr = readfile.read_attribute(inps.file)
if attr['FILE_TYPE'] == 'timeseries' and inps.dset and '_' in inps.dset:
inps.ref_date, inps.dset = inps.dset.split('_')
else:
inps.ref_date = None
# read data
print('read data from file: {}'.format(inps.file))
array, attr = readfile.read(inps.file, datasetName=inps.dset)
if attr['FILE_TYPE'] == 'timeseries' and inps.ref_date:
array -= readfile.read(inps.file, datasetName=inps.ref_date)[0]
# output filename
if not inps.outfile:
fbase = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
inps.outfile = fbase + GDAL_DRIVER2EXT.get(inps.out_format, '')
else:
inps.outfile = os.path.abspath(inps.outfile)
# coordinate info
rasterOrigin = (float(attr['X_FIRST']), float(attr['Y_FIRST']))
xStep = float(attr['X_STEP'])
yStep = float(attr['Y_STEP'])
# convert array to raster
reversed_arr = array[::-1]
array2raster(reversed_arr, inps.outfile, inps.out_format, rasterOrigin,
xStep, yStep)
return
def update_inps_with_file_metadata(inps, metadata):
# Subset
# Convert subset input into bounding box in radar / geo coordinate
# geo_box = None if atr is not geocoded.
coord = ut.coordinate(metadata)
inps.pix_box, inps.geo_box = subset.subset_input_dict2box(
vars(inps), metadata)
inps.pix_box = coord.check_box_within_data_coverage(inps.pix_box)
inps.geo_box = coord.box_pixel2geo(inps.pix_box)
# Out message
data_box = (0, 0, inps.width, inps.length)
vprint('data coverage in y/x: ' + str(data_box))
vprint('subset coverage in y/x: ' + str(inps.pix_box))
vprint('data coverage in lat/lon: ' + str(coord.box_pixel2geo(data_box)))
vprint('subset coverage in lat/lon: ' + str(inps.geo_box))
vprint(
'------------------------------------------------------------------------'
)
# DEM contour display
if max(inps.pix_box[3] - inps.pix_box[1],
inps.pix_box[2] - inps.pix_box[0]) > 2e3:
inps.disp_dem_contour = False
if inps.dem_file:
vprint(
'area exceed 2000 pixels, turn off default DEM contour display'
)
# Multilook, if too many subplots in one figure for less memory and faster speed
if inps.multilook_num > 1:
inps.multilook = True
# Colormap
inps.colormap = pp.check_colormap_input(metadata,
inps.colormap,
datasetName=inps.dset[0],
cmap_lut=inps.cmap_lut,
print_msg=inps.print_msg)
# Reference Point
# Convert ref_lalo if existed, to ref_yx, and use ref_yx for the following
# ref_yx is referenced to input data coverage, not subseted area for display
if inps.ref_lalo and inps.geo_box:
inps.ref_yx = [
coord.lalo2yx(inps.ref_lalo[0], coord_type='lat'),
coord.lalo2yx(inps.ref_lalo[1], coord_type='lon')
]
vprint('input reference point in lat/lon: {}'.format(inps.ref_lalo))
vprint('input reference point in y /x : {}'.format(inps.ref_yx))
# ref_lalo
if inps.ref_yx and inps.geo_box:
inps.ref_lalo = [
coord.yx2lalo(inps.ref_yx[0], coord_type='y'),
coord.yx2lalo(inps.ref_yx[1], coord_type='x')
]
elif 'REF_LAT' in metadata.keys():
inps.ref_lalo = [
float(metadata['REF_LAT']),
float(metadata['REF_LON'])
]
else:
inps.ref_lalo = None
# Points of interest
inps = pp.read_point2inps(inps, coord)
# Unit and Wrap
inps.disp_unit, inps.wrap = pp.check_disp_unit_and_wrap(
metadata,
disp_unit=inps.disp_unit,
wrap=inps.wrap,
wrap_range=inps.wrap_range,
print_msg=inps.print_msg)
# Min / Max - Display
if not inps.vlim:
if (any(i in inps.key.lower() for i in ['coherence', '.cor'])
or (inps.key == 'ifgramStack'
and inps.dset[0].split('-')[0] in ['coherence'])
or inps.dset[0] == 'cmask'):
inps.vlim = [0.0, 1.0]
elif inps.key in ['.int'] or inps.wrap:
inps.vlim = inps.wrap_range
# Transparency - Alpha
if not inps.transparency:
# Auto adjust transparency value when showing shaded relief DEM
if inps.dem_file and inps.disp_dem_shade:
inps.transparency = 0.8
else:
inps.transparency = 1.0
# Flip Left-Right / Up-Down
if inps.auto_flip:
inps.flip_lr, inps.flip_ud = pp.auto_flip_direction(
metadata, print_msg=inps.print_msg)
# Figure Title
if not inps.fig_title:
inps.fig_title = pp.auto_figure_title(metadata['FILE_PATH'],
datasetNames=inps.dset,
inps_dict=vars(inps))
vprint('figure title: ' + inps.fig_title)
# Figure output file name
if not inps.outfile:
inps.outfile = ['{}{}'.format(inps.fig_title, inps.fig_ext)]
inps = update_figure_setting(inps)
return inps
def main(iargs=None):
inps = cmd_line_parse(iargs)
inps.work_dir = os.path.abspath(os.path.dirname(inps.ts_file))
inps.cbar_file = os.path.join(inps.work_dir, 'google_earth_cbar.png')
inps.star_file = os.path.join(inps.work_dir, "star.png")
inps.dot_file = os.path.join(inps.work_dir, "shaded_dot.png")
inps.dygraph_file = os.path.join(inps.work_dir, "dygraph-combined.js")
inps.kml_data_dir = os.path.join(inps.work_dir, 'kml_data')
## Define file names
if inps.outfile:
inps.outfile_base = os.path.splitext(os.path.basename(inps.outfile))[0]
else:
inps.outfile_base = plot.auto_figure_title(inps.ts_file,
inps_dict=vars(inps))
kml_root_file = os.path.join(inps.work_dir,
'{}_root.kml'.format(inps.outfile_base))
kmz_file = os.path.join(inps.work_dir, '{}.kmz'.format(inps.outfile_base))
## read data
ts_obj = timeseries(inps.ts_file)
ts_obj.open()
length, width = ts_obj.length, ts_obj.width
inps.metadata = ts_obj.metadata
lats, lons = ut.get_lat_lon(ts_obj.metadata)
print('input data shape in row/col: {}/{}'.format(length, width))
vel = readfile.read(inps.vel_file, datasetName='velocity')[0] * 100.
# Set min/max velocity for colormap
if inps.vlim is None:
inps.vlim = [np.nanmin(vel), np.nanmax(vel)]
if inps.wrap:
print('re-wrapping data to {} cm/year for color coding'.format(
inps.vlim))
##--------- Create root KML file with network links to data KML files --------------##
kml_root_doc = KML.Document()
# 1 Create Overlay element for colorbar
cbar_overlay = generate_cbar_element(cbar_file=inps.cbar_file,
vmin=inps.vlim[0],
vmax=inps.vlim[1],
cmap=inps.colormap)
kml_root_doc.append(cbar_overlay)
# 2 Generate the placemark for the Reference Pixel
ref_point = create_reference_point_element(inps, lats, lons, ts_obj)
print('add reference point.')
ref_folder = KML.Folder(KML.name("ReferencePoint"))
ref_folder.append(ref_point)
kml_root_doc.append(ref_folder)
# 3 Create data folder to contain actual data elements
data_folder = KML.Folder(KML.name("Data"))
for i, step in enumerate(inps.steps):
net_link = generate_network_link(inps,
ts_obj,
step=step,
lod=(inps.lods[i], inps.lods[i + 1]))
if net_link is not None:
data_folder.append(net_link)
kml_root_doc.append(data_folder)
##---------------------------- Write root KML file ------------------------------##
print('-' * 30)
print('writing ' + kml_root_file)
kml_root = KML.kml()
kml_root.append(kml_root_doc)
with open(kml_root_file, 'w') as f:
f.write(etree.tostring(kml_root, pretty_print=True).decode('utf-8'))
## Copy auxiliary files
res_dir = os.path.join(os.path.dirname(mintpy.__file__), "data")
for fname in [inps.star_file, inps.dot_file, inps.dygraph_file]:
src_file = os.path.join(res_dir, os.path.basename(fname))
shutil.copy2(src_file, inps.work_dir)
print("copy {} to the local directory".format(src_file))
## Generate KMZ file
# 1) go to the directory of kmz file
run_dir = os.path.abspath(os.getcwd())
os.chdir(inps.work_dir)
# 2) zip all data files
with ZipFile(kmz_file, 'w') as fz:
kml_data_files = get_all_file_paths(inps.kml_data_dir)
for fname in [
kml_root_file, inps.cbar_file, inps.dygraph_file,
inps.dot_file, inps.star_file
] + kml_data_files:
fz.write(os.path.relpath(fname))
os.remove(fname)
shutil.rmtree(inps.kml_data_dir)
# 3) go back to the running directory
os.chdir(run_dir)
print('merged all files to {}'.format(kmz_file))
print('Done.')
print('Open {} in Google Earth and play!'.format(kmz_file))
return
def main(iargs=None):
inps = cmd_line_parse(iargs)
# 1. Read metadata and data
k = readfile.read_attribute(inps.file)['FILE_TYPE']
if k == 'timeseries' and inps.dset and '_' in inps.dset:
inps.ref_date, inps.dset = inps.dset.split('_')
else:
inps.ref_date = None
atr = readfile.read_attribute(inps.file, datasetName=inps.dset)
# pix_box
inps.pix_box = subset.subset_input_dict2box(vars(inps), atr)[0]
inps.pix_box = ut.coordinate(atr).check_box_within_data_coverage(
inps.pix_box)
data_box = (0, 0, int(atr['WIDTH']), int(atr['LENGTH']))
print('data coverage in y/x: {}'.format(data_box))
print('subset coverage in y/x: {}'.format(inps.pix_box))
atr = attr.update_attribute4subset(atr, inps.pix_box)
# read data
data = readfile.read(inps.file, datasetName=inps.dset, box=inps.pix_box)[0]
if k == 'timeseries' and inps.ref_date:
data -= readfile.read(inps.file,
datasetName=inps.ref_date,
box=inps.pix_box)[0]
# mask
mask = pp.read_mask(inps.file,
mask_file=inps.mask_file,
datasetName=inps.dset,
box=inps.pix_box)[0]
if mask is not None:
print('masking out pixels with zero value in file: {}'.format(
inps.mask_file))
data[mask == 0] = np.nan
if inps.zero_mask:
print('masking out pixels with zero value')
data[data == 0] = np.nan
del mask
# Data Operation - Display Unit & Rewrapping
(data, inps.disp_unit, inps.disp_scale,
inps.wrap) = pp.scale_data4disp_unit_and_rewrap(
data,
metadata=atr,
disp_unit=inps.disp_unit,
wrap=inps.wrap,
wrap_range=inps.wrap_range)
if inps.wrap:
inps.vlim = inps.wrap_range
# 2. Generate Google Earth KMZ
# 2.1 Common settings
# disp min/max and colormap
cmap_lut = 256
if not inps.vlim:
cmap_lut, inps.vlim = pp.auto_adjust_colormap_lut_and_disp_limit(data)
inps.colormap = pp.auto_colormap_name(atr, inps.colormap)
inps.colormap = pp.ColormapExt(inps.colormap, cmap_lut).colormap
inps.norm = colors.Normalize(vmin=inps.vlim[0], vmax=inps.vlim[1])
# Output filename
inps.fig_title = pp.auto_figure_title(inps.file,
datasetNames=inps.dset,
inps_dict=vars(inps))
if not inps.outfile:
inps.outfile = '{}.kmz'.format(inps.fig_title)
inps.outfile = os.path.abspath(inps.outfile)
# 2.2 Write KMZ file
if 'Y_FIRST' in atr.keys():
# create ground overlay KML for file in geo-coord
write_kmz_overlay(
data,
meta=atr,
out_file=inps.outfile,
inps=inps,
)
else:
# create placemark KML for file in radar-coord
write_kmz_placemark(
data,
meta=atr,
out_file=inps.outfile,
geom_file=inps.geom_file,
inps=inps,
)
return inps.outfile
def main(iargs=None):
inps = cmd_line_parse(iargs)
inps.work_dir = os.path.abspath(os.path.dirname(inps.ts_file))
inps.cbar_file = os.path.join(inps.work_dir, 'google_earth_cbar.png')
inps.star_file = os.path.join(inps.work_dir, "star.png")
inps.dot_file = os.path.join(inps.work_dir, "shaded_dot.png")
inps.dygraph_file = os.path.join(inps.work_dir, "dygraph-combined.js")
inps.kml_data_dir = os.path.join(inps.work_dir, 'kml_data')
## Define file names
inps.outfile_base = plot.auto_figure_title(inps.ts_file, inps_dict=vars(inps))
kml_master_file = os.path.join(inps.work_dir, '{}_master.kml'.format(inps.outfile_base))
kmz_file = os.path.join(inps.work_dir, '{}.kmz'.format(inps.outfile_base))
## read data
ts_obj = timeseries(inps.ts_file)
ts_obj.open()
length, width = ts_obj.length, ts_obj.width
inps.metadata = ts_obj.metadata
lats, lons = ut.get_lat_lon(ts_obj.metadata)
print('input data shape in row/col: {}/{}'.format(length, width))
vel = readfile.read(inps.vel_file, datasetName='velocity')[0] * 100.
# Set min/max velocity for colormap
if inps.vlim is None:
inps.vlim = [np.nanmin(vel), np.nanmax(vel)]
##--------- Create master KML file with network links to data KML files --------------##
kml_master_doc = KML.Document()
# 1 Create Overlay element for colorbar
cbar_overlay = generate_cbar_element(cbar_file=inps.cbar_file,
vmin=inps.vlim[0],
vmax=inps.vlim[1],
cmap=inps.colormap)
kml_master_doc.append(cbar_overlay)
# 2 Generate the placemark for the Reference Pixel
ref_point = create_reference_point_element(inps, lats, lons, ts_obj)
print('add reference point.')
ref_folder = KML.Folder(KML.name("ReferencePoint"))
ref_folder.append(ref_point)
kml_master_doc.append(ref_folder)
# 3 Create data folder to contain actual data elements
net_link1 = generate_network_link(inps, ts_obj, step=inps.steps[0], lod=(0, inps.lods[0]))
net_link2 = generate_network_link(inps, ts_obj, step=inps.steps[1], lod=(inps.lods[0], inps.lods[1]))
net_link3 = generate_network_link(inps, ts_obj, step=inps.steps[2], lod=(inps.lods[1], inps.lods[2]))
# 3.3 Append network links to data folder
data_folder = KML.Folder(KML.name("Data"))
data_folder.append(net_link1)
data_folder.append(net_link2)
data_folder.append(net_link3)
kml_master_doc.append(data_folder)
##---------------------------- Write master KML file ------------------------------##
print('-'*30)
print('writing ' + kml_master_file)
kml_master = KML.kml()
kml_master.append(kml_master_doc)
with open(kml_master_file, 'w') as f:
f.write(etree.tostring(kml_master, pretty_print=True).decode('utf-8'))
## Copy auxiliary files
res_dir = os.path.join(os.path.dirname(__file__), "../docs/resources")
for fname in [inps.star_file, inps.dot_file, inps.dygraph_file]:
src_file = os.path.join(res_dir, os.path.basename(fname))
shutil.copy2(src_file, inps.work_dir)
print("copy {} to the local directory".format(src_file))
## Generate KMZ file
kml_files_str = ''
for fname in [kml_master_file, inps.kml_data_dir,
inps.cbar_file,inps.dygraph_file,
inps.dot_file, inps.star_file]:
kml_files_str += ' {}'.format(os.path.basename(fname))
cmd = 'cd {}; zip -r {} {}'.format(inps.work_dir, kmz_file, kml_files_str)
print('writing {} from kml files'.format(kmz_file))
os.system(cmd)
## Remove extra files from file tree after KMZ generation
cmd = 'cd {}; rm -r {}'.format(inps.work_dir, kml_files_str)
os.system(cmd)
print('Done.')
print('Open {} in Google Earth!'.format(kmz_file))
return
def main(iargs=None):
## 1. Read command line variables
inps = cmd_line_parse(iargs)
## 2. Define file names
out_name_base = plot.auto_figure_title(inps.ts_file, inps_dict=vars(inps))
kml_file_master = '{}_master.kml'.format(out_name_base)
kmz_file = '{}.kmz'.format(out_name_base)
## 4. read data
ts_obj = timeseries(inps.ts_file)
ts_obj.open()
length, width = ts_obj.length, ts_obj.width
lats, lons = get_lat_lon(ts_obj.metadata)
vel = readfile.read(inps.vel_file, datasetName='velocity')[0] * 100.
# Set min/max velocity for colormap
if inps.vlim is None:
inps.vlim = [np.nanmin(vel), np.nanmax(vel)]
## 5. Generate large and small KML files for different view heights
small_dset_step = 20 # Increase this for coarser resolution in small dset
large_dset_step = 3 # Decrease this for finer resolution in large dset
full_dset_step = 1 # Full resolution for deforming regions
box_list = split_into_sub_boxes((length, width)) # Create list of unique regions
deforming_box_list = get_boxes4deforming_area(inps.vel_file, inps.mask_file)
## 6. Create master KML file with network links to data KML files
kml_master = KML.kml()
kml_master_document = KML.Document()
# 6.1 Create Overlay element for colorbar
cbar_overlay, cbar_png_file = generate_cbar_element(inps)
kml_master_document.append(cbar_overlay)
# 6.2 Generate the placemark for the Reference Pixel
reference_point, star_file = create_reference_point_element(inps, lats, lons, ts_obj)
print('add reference point.')
reference_folder = KML.Folder(KML.name("ReferencePoint"))
reference_folder.append(reference_point)
kml_master_document.append(reference_folder)
# 6.3 Create data folder to contain actual data elements
data_folder = KML.Folder(KML.name("Data"))
network_link_1, dot_file, _, _ = generate_network_link(inps, ts_obj, box_list, small_dset_step, (0, 1500))
network_link_2, _, dygraph_file, _ = generate_network_link(inps, ts_obj, box_list, large_dset_step, (1500, 4000))
network_link_3, _, _, kml_data_files_directory = generate_network_link(inps, ts_obj, deforming_box_list, full_dset_step, (4000, -1))
# 6.3.3 Append network links to data folder
data_folder.append(network_link_1)
data_folder.append(network_link_2)
data_folder.append(network_link_3)
kml_master_document.append(data_folder)
kml_master.append(kml_master_document)
## 7 Write master KML file
print('writing ' + kml_file_master)
with open(kml_file_master, 'w') as f:
f.write(etree.tostring(kml_master, pretty_print=True).decode('utf-8'))
## 8 Copy auxiliary files
# 8.1 shaded_dot file
dot_path = os.path.join(os.path.dirname(__file__), "../docs/resources", dot_file)
cmdDot = "cp {} {}".format(dot_path, dot_file)
print("copying {} for point.".format(dot_file))
os.system(cmdDot)
# 8.2 star file
star_path = os.path.join(os.path.dirname(__file__), "../docs/resources", star_file)
cmdStar = "cp {} {}".format(star_path, star_file)
print("copying {} for reference point.".format(star_file))
os.system(cmdStar)
# 8.3 dygraph-combined.js file
dygraph_path = os.path.join(os.path.dirname(__file__), "../docs/resources", dygraph_file)
cmdDygraph = "cp {} {}".format(dygraph_path, dygraph_file)
print("copying {} for interactive plotting.".format(dygraph_file))
os.system(cmdDygraph)
## 9. Generate KMZ file
cmdKMZ = 'zip -r {} {} {} {} {} {} {}'.format(kmz_file, kml_data_files_directory, kml_file_master, cbar_png_file, dygraph_file, dot_file, star_file)
print('writing {}\n{}'.format(kmz_file, cmdKMZ))
os.system(cmdKMZ)
# 9.1 Remove extra files from file tree after KMZ generation
cmdClean = 'rm -r {} {} {} {} {} {}'.format(kml_data_files_directory, kml_file_master, cbar_png_file, dygraph_file, dot_file, star_file)
os.system(cmdClean)
print('Done.')
return
