def combine_all_files(datestr, input_dirs, output_dir): print("\nCombining files for date %s" % datestr) xdata, ydata, zdata0 = netcdf_read_write.read_grd_xyz(input_dirs[0] + "/" + datestr + ".grd") xdata, ydata, zdata1 = netcdf_read_write.read_grd_xyz(input_dirs[1] + "/" + datestr + ".grd") zdata_total = np.zeros(np.shape(zdata0)) for j in range(len(ydata)): if np.mod(j, 200) == 0: print(j) for k in range(len(xdata)): vector = [zdata0[j][k], zdata1[j][k]] # , zdata2[j][k], zdata3[j][k], zdata4[j][k], zdata5[j][k], zdata6[j][k] ]; zdata_total[j][k] = np.sum(vector) output_file = output_dir + "/" + datestr + ".grd" output_plot = output_dir + "/" + datestr + ".png" netcdf_read_write.produce_output_netcdf(xdata, ydata, zdata_total, "mm", output_file) netcdf_read_write.produce_output_plot(output_file, datestr, output_plot, "mm", aspect=1.0, invert_yaxis=True, vmin=-50, vmax=100) return
def write_gmtsar2roipac_phase(input_directory, phasefile, phasefilt_file, ampfile, outfilename, outfile_filt): """ A function that reads phase and amplitude grids in GMT format and writes a Binary format file with the real and imaginary components of the values. """ # INPUTS [xdata, ydata, phase] = netcdf_read_write.read_grd_xyz(phasefile) [xdata, ydata, phasefilt] = netcdf_read_write.read_grd_xyz(phasefilt_file) [xdata, ydata, amp] = netcdf_read_write.read_grd_xyz(ampfile) width = len(xdata) length = len(ydata) # # FOR THE PHASE AND AMPLITUDE DATA, reformatting the data and making initial plot. phase_1d = np.reshape(phase, (np.size(phase), )) phasefilt_1d = np.reshape(phasefilt, (np.size(phasefilt), )) amp_1d = np.reshape(amp, (np.size(amp), )) amp_1d = [x * 1e12 for x in amp_1d] # Fixing the different GMTSAR definition of amplitude. # # WRITE THEM OUT IN BINARY FORMAT. print("converting phase_1d to real,imag.") [real, imag] = phase_amp2real_imag(phase_1d, amp_1d) write_binary_roipac_real_imag(outfilename, real, imag) print("converting phase_1d_filt to real,imag.") [real, imag] = phase_amp2real_imag(phasefilt_1d, amp_1d) write_binary_roipac_real_imag(outfile_filt, real, imag) return [width, length]
def reader(filepathslist): """This function takes in a list of filepaths that each contain a 2d array of data, effectively taking in a cuboid of data. It splits and stores this data in a named tuple which is returned. This can then be used to extract key pieces of information.""" filepaths = [] dates_correct, date_deltas = [], [] xvalues, yvalues, zvalues = [], [], [] for i in range(len(filepathslist)): print(filepathslist[i]) filepaths.append(filepathslist[i]) datesplit = filepathslist[i].split('/') date_new = datesplit[-2].replace(datesplit[-2][0:7], str(int(datesplit[-2][0:7]) + 1)) date_new = date_new.replace(date_new[8:15], str(int(date_new[8:15]) + 1)) dates_correct.append(date_new) delta = abs( datetime.strptime(dates_correct[i][0:7], '%Y%j') - datetime.strptime(dates_correct[i][8:15], '%Y%j')) date_deltas.append(delta.days / 365.24) xdata, ydata, zdata = rwr.read_grd_xyz(filepathslist[i]) xvalues = xdata yvalues = ydata zvalues.append(zdata) if i == round(len(filepathslist) / 2): print('halfway done reading files...') mydata = data(filepaths=np.array(filepaths), dates_correct=np.array(dates_correct), date_deltas=np.array(date_deltas), xvalues=np.array(xvalues), yvalues=np.array(yvalues), zvalues=np.array(zvalues)) return mydata
def make_referenced_unwrapped(rowref, colref, prior_staging_directory, post_staging_directory): files = glob.glob(prior_staging_directory + "/*") print("Imposing reference pixel on %d files in %s; saving output in %s" % (len(files), prior_staging_directory, post_staging_directory)) out_dir = post_staging_directory + "/" subprocess.call(['mkdir', '-p', out_dir], shell=False) for filename in files: individual_name = filename.split('/')[-1] print(individual_name) [xdata, ydata, zdata] = netcdf_read_write.read_grd_xyz(filename) # xdata is range/columns, ydata is azimuth/rows # Here we subtract the value of zdata[rowref][colref] to fix the refernece pixel. # referenced_zdata[rowref][colref]=0 by definition. referenced_zdata = np.zeros(np.shape(zdata)) for i in range(len(ydata)): for j in range(len(xdata)): referenced_zdata[i][j] = zdata[i][j] - zdata[rowref][colref] print(referenced_zdata[rowref][colref]) outname = out_dir + individual_name netcdf_read_write.produce_output_netcdf(xdata, ydata, referenced_zdata, 'phase', outname) netcdf_read_write.flip_if_necessary(outname) return
def remove_plane(filename, planefile, outfile, m1, m2, m3): xvalues, yvalues, zvalues = rwr.read_grd_xyz(filename) i, j = 0, 0 new_z = np.zeros((len(yvalues), len(xvalues))) for z in np.nditer(zvalues): new_z[i, j] = zvalues[i, j] - (m1 + m2 * xvalues[j] + m3 * yvalues[i]) j += 1 if j == len(xvalues): j = 0 i += 1 if i == len(yvalues): i = 0 print(new_z[0, 0]) new_z = np.flipud(new_z) print(new_z[0, 0]) rwr.produce_output_netcdf(xvalues, yvalues, np.flipud(new_z), 'unwrapped phase', outfile) rwr.flip_if_necessary(outfile) outfile1 = outfile.replace("no_ramp.grd", "no_ramp_comparison.png") fr = netcdf.netcdf_file(outfile, 'r') xread = fr.variables['x'] yread = fr.variables['y'] zread = fr.variables['z'] zread_copy = zread[:][:].copy() fr2 = netcdf.netcdf_file(filename, 'r') xread2 = fr2.variables['x'] yread2 = fr2.variables['y'] zread2 = fr2.variables['z'] zread2_copy = zread2[:][:].copy() fig = plt.figure(figsize=(7, 10)) ax1 = plt.subplot(121) old = ax1.imshow(zread2_copy, aspect=1.2) ax1.invert_xaxis() ax1.get_xaxis().set_ticks([]) ax1.get_yaxis().set_ticks([]) ax1.set_xlabel("Range", fontsize=16) ax1.set_ylabel("Azimuth", fontsize=16) ax2 = plt.subplot(122) new = ax2.imshow(zread_copy, aspect=1.2, vmin=np.nanmin(zread_copy), vmax=np.nanmax(zread2_copy)) ax2.invert_xaxis() ax2.get_xaxis().set_ticks([]) ax2.get_yaxis().set_ticks([]) ax2.set_xlabel("Range", fontsize=16) cb = plt.colorbar(new) cb.set_label('unwrapped phase', size=16) plt.savefig(outfile1) plt.close() rwr.produce_output_plot(outfile, 'Ramp removed', outfile.replace('grd', 'png'), 'unwraped phase') return
def overlay_gps(netcdfname, smoothing, misfit): z = rwr.read_grd(netcdfname) ma = np.nanmax(z, axis=None, out=None) mi = np.nanmin(z, axis=None, out=None) xread, yread, zread = rwr.read_grd_xyz(netcdfname) # Make a plot fig = plt.figure(figsize=(7, 10)) ax1 = fig.add_axes([0.0, 0.1, 0.9, 0.8]) image = plt.imshow( zread, aspect=1.2, extent=[15.984871407, 21116.0151286, 12196, 4.4408920985 * (10**-16)], cmap='jet', vmin=-10, vmax=10) plt.gca().invert_xaxis() # plt.gca().invert_yaxis() plt.title('Reasonable WNSBAS without ramps - smoothing factor: ' + str(smoothing) + ' - Misfit: ' + str(misfit)) plt.gca().set_xlabel("Range", fontsize=16) plt.gca().set_ylabel("Azimuth", fontsize=16) scatter = plt.gca().scatter(xfinal, yfinal, c=velfinal, marker='v', s=100, cmap='jet', vmin=-10, vmax=10) cb = plt.colorbar(image) cb.set_label('velocity in mm/yr', size=16) plt.show() return
def how_many_nans(filename): [xdata, ydata, zdata] = netcdf_read_write.read_grd_xyz(filename) nan_pixels = np.count_nonzero(np.isnan(zdata)) total_pixels = np.shape(zdata)[0] * np.shape(zdata)[1] print("For file %s: %d pixels of %d are NaNs (%f percent)." % (filename, nan_pixels, total_pixels, 100 * float(nan_pixels / float(total_pixels)))) return [nan_pixels, total_pixels]
def plot_grid_file(filename, figname): [xdata, ydata, zdata] = netcdf_read_write.read_grd_xyz(filename) plt.figure() plt.imshow(zdata) plt.colorbar() plt.savefig(figname + '.eps') plt.close() return
def make_outlier_mask_for_stack(filelist, maskfile, outlier_cutoff=1e4): # Make a mask that is ones and nans # Given a co-registered stack # If a pixel is above the outlier cutoff in any image of the stack, make a nanmask that masks that pixel. x, y, z = netcdf_read_write.read_grd_xyz( filelist[1]) # just to get the shape of the outputs crazy_mask = np.ones(np.shape(z)) for ifile in filelist: print(ifile) x, y, ztemp = netcdf_read_write.read_grd_xyz(ifile) for i in range(len(y)): for j in range(len(x)): if abs(ztemp[i][j]) > outlier_cutoff: crazy_mask[i][j] = np.nan # Put all the crazy pixels into a mask (across all images in the stack). netcdf_read_write.produce_output_netcdf(x, y, crazy_mask, "", maskfile) return
def produce_min_max(filename, xyz=False): if xyz == False: x, y, z = netcdf_read_write.read_netcdf4_xyz(filename) else: x, y, z = netcdf_read_write.read_grd_xyz(filename) print("File:", filename) print("Max: ", np.nanmax(z)) print("Min: ", np.nanmin(z)) print("Shape: ", np.shape(z)) return
def number_below_value(filename, value): [xdata, ydata, zdata] = netcdf_read_write.read_grd_xyz(filename) count = 0 for i in range(len(ydata)): for j in range(len(xdata)): if zdata[i][j] < value: count = count + 1 total_pixels = np.shape(zdata)[0] * np.shape(zdata)[1] print("For file %s: %d pixels of %d are below %f (%f percent)." % (filename, count, total_pixels, value, 100 * float(count / float(total_pixels)))) return
def write_gmtsar2roipac_topo(infile, out_topo): """ A function that reads a GMT topographic grid and writes the corresponding .hgt format for use with roipac functions. """ [xdata, ydata, topo] = netcdf_read_write.read_grd_xyz(infile); width = len(xdata); length = len(ydata); topo = np.flipud(topo); # formatting correct when you flip up/down. topo_1d = np.reshape(topo, (np.size(topo),)); # WRITE THE TOPO OUT IN BINARY FORMAT write_binary_topo(out_topo, topo_1d, topo_1d, width); # outputs(topo_1d, topo_1d, width, length, 'mendocino_topo_orig.eps'); return [width, length];
# Plot the residuals. import numpy as np import matplotlib.pyplot as plt import subprocess import netcdf_read_write grdname = "cas_slab1.0_clip.grd" xyzname = "casc_geometry.xyz" detrend_xyz = "detrended_geometry.xyz" detrend_grd = "detrended_N4.grd" top_range = 47 # degrees north. [xdata, ydata, zdata] = netcdf_read_write.read_grd_xyz(grdname) xdata = np.flipud(xdata) # plt.figure(); # plt.contourf(xdata, ydata, zdata); # plt.colorbar(); # plt.savefig('test.eps'); outfile = open(xyzname, 'w') for i in range(len(ydata)): for j in range(len(xdata)): if ydata[i] < top_range: if ~np.isnan(zdata[i][j]): outfile.write("%f %f %f\n" % (xdata[j], ydata[i], zdata[i][j])) outfile.close()
def reshape_TS_into_standard(outdir, earlyfile, cofile, latefile, outfile): # This is not particular general. It's using hard-coded information about time axis # and the timing of the earthquake. # It's for track 26509. # This function pastes together a pre-seismic, co-seismic, and post-seismic set of time series or jumps. # On the same xy grid. tolerance = 300 # Purposely killing all pixels above this value. print("Reshaping UAVSAR file into single TS File") [tdata1, xdata1, ydata1, zdata1] = netcdf_read_write.read_3D_netcdf(earlyfile) [xdata2, ydata2, zdata2] = netcdf_read_write.read_grd_xyz(cofile) [tdata3, xdata3, ydata3, zdata3] = netcdf_read_write.read_3D_netcdf(latefile) print(np.shape(zdata1), np.shape(zdata2), np.shape(zdata3)) ynum = np.shape(zdata1)[1] xnum = np.shape(zdata1)[2] znum = np.shape(zdata1)[0] + np.shape(zdata3)[0] total_data = np.zeros([znum, ynum, xnum]) print(np.shape(total_data)) for i in range(np.shape(zdata1)[0]): temp = zdata1[i, :, :] temp[abs(temp) > tolerance] = np.nan # killing outliers total_data[i, :, :] = temp # doing this six times. print("Early data Slice %d" % i) temp = zdata2 temp[abs(temp) > tolerance] = np.nan total_data[7, :, :] = np.add(total_data[6, :, :], zdata2) # The coseismic chunk print("Coseismic data slice 7") for i in range(1, np.shape(zdata3)[0]): temp = zdata3[i, :, :] temp[abs(temp) > tolerance] = np.nan # killing outliers total_data[i + np.shape(zdata1)[0], :, :] = np.add( temp, total_data[7, :, :]) print("Postseismic data slice %d " % (i + np.shape(zdata1)[0])) dtarray = [] dtarray.append(dt.datetime.strptime("2009-04-24", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2009-09-21", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2010-04-12", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2010-07-01", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2010-12-01", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2011-05-18", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2011-11-10", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2012-09-26", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2013-05-24", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2014-06-11", "%Y-%m-%d")) # Hard-coded dtarray.append(dt.datetime.strptime("2017-11-01", "%Y-%m-%d")) # Hard-coded zunits = "mm" print(np.shape(total_data)) netcdf_read_write.produce_output_timeseries(xdata1, ydata1, total_data, dtarray, zunits, outfile) stacking_utilities.plot_full_timeseries(outfile, dtarray, outdir + "TS_cumulative.png", vmin=-50, vmax=200, aspect=1 / 8) stacking_utilities.plot_incremental_timeseries(outfile, dtarray, outdir + "TS_incremental.png", vmin=-50, vmax=100, aspect=1 / 8) return
def inputs(inputfile, demfile): [x,y,topo]=netcdf_read_write.read_grd_xyz(demfile); [xdata, ydata, zdata]=netcdf_read_write.read_grd_xyz(inputfile); topo=np.flipud(topo); return [topo, xdata, ydata, zdata];
def plane_fitter(filename, outfile): """This function fits the inputted data (filename) to the model: z = A + Bx + Cy. It saves the model in outfile. It plots a comparison of the data and the model, and also returns the model parameters A, B and C.""" xvalues, yvalues, zvalues = rwr.read_grd_xyz(filename) i, j = 0, 0 d, x, y = [], [], [] for z in np.nditer(zvalues): if np.isnan(z) == False: d.append(zvalues[i, j]) x.append(xvalues[j]) y.append(yvalues[i]) j += 1 if j == len(xvalues): j = 0 i += 1 if i == len(yvalues): i = 0 temp = np.ones(len(d)) G = np.column_stack((temp, x, y)) GTG = np.dot(np.transpose(G), G) GTd = np.dot(np.transpose(G), d) soln = np.dot(np.linalg.inv(GTG), GTd) i, j = 0, 0 model_z = np.zeros((len(yvalues), len(xvalues))) for z in np.nditer(zvalues): model_z[i, j] = soln[0] + soln[1] * xvalues[j] + soln[2] * yvalues[i] j += 1 if j == len(xvalues): j = 0 i += 1 if i == len(yvalues): i = 0 rwr.produce_output_netcdf(xvalues, yvalues, model_z, 'unwrapped phase', outfile) rwr.flip_if_necessary(outfile) outfile1 = outfile.replace("model.grd", "model_comparison.png") fr = netcdf.netcdf_file(outfile, 'r') xread = fr.variables['x'] yread = fr.variables['y'] zread = fr.variables['z'] zread_copy = zread[:][:].copy() fr2 = netcdf.netcdf_file(filename, 'r') xread2 = fr2.variables['x'] yread2 = fr2.variables['y'] zread2 = fr2.variables['z'] zread2_copy = zread2[:][:].copy() fig = plt.figure(figsize=(7, 10)) ax1 = plt.subplot(121) old = ax1.imshow(zread2_copy, aspect=1.2) ax1.invert_xaxis() ax1.get_xaxis().set_ticks([]) ax1.get_yaxis().set_ticks([]) ax1.set_xlabel("Range", fontsize=16) ax1.set_ylabel("Azimuth", fontsize=16) ax2 = plt.subplot(122) new = ax2.imshow(zread_copy, aspect=1.2, vmin=np.nanmin(zread_copy), vmax=np.nanmax(zread2_copy)) ax2.invert_xaxis() ax2.get_xaxis().set_ticks([]) ax2.get_yaxis().set_ticks([]) ax2.set_xlabel("Range", fontsize=16) cb = plt.colorbar(new) cb.set_label('unwrapped phase', size=16) plt.savefig(outfile1) plt.close() return soln[0], soln[1], soln[2]
est = estimated_gpsvel(filenames[i][0]) misfit = ncf.misfit(velfinal, est) print(result(filenames[i][0], misfit, filenames[i][1])) # z = rwr.read_grd(filenames[-2][0]) # counter = [] # i, j = 0,0 # for x in range(len(xfinal_ratioed)): # pixel_box = z[(yfinal_ratioed[x]-50):(yfinal_ratioed[x]+51),(xfinal_ratioed[x]-50):(xfinal_ratioed[x]+51) ] # print(np.shape(pixel_box)) # for v in np.nditer(pixel_box): # if np.isnan(v) == False: # counter.append(v) # print(len(counter)) x1, y1, z1 = rwr.read_grd_xyz('signalspread_please_test.nc') x2, y2, z2 = rwr.read_grd_xyz(filenames[-2][0]) thing1 = z1[1200:1424, 400:660] thing2 = z2[1200:1424, 400:660] rwr.produce_output_netcdf(x1[400:660], y1[1200:1424], thing1, 'signal', 'possible_fault_info.grd') rwr.flip_if_necessary('possible_fault_info.grd') rwr.produce_output_plot('possible_fault_info.grd', '', 'possible_fault_info.png', '%') rwr.produce_output_netcdf(x2[400:660], y2[1200:1424], thing2, 'velocity', 'possible_fault_info_vel.grd') rwr.flip_if_necessary('possible_fault_info_vel.grd') [x, y] = np.meshgrid(x1[400:660], y1[1200:1424]) [x_, y_] = np.meshgrid(x2[400:660], y2[1200:1424])