def getplotvals(self):
point_list = []
# Generate the list of points.
toto = self.toelevation
if (toto <= 0):
toto = toto - 1
else:
toto = toto + 1
for i in np.arange(self.startelevation, toto, self.spacing):
point_list.append(
Point(self.startingpoint.longitude,
self.startingpoint.latitude,
elevation=i))
u = UCVM(install_dir=self.installdir,
config_file=self.configfile,
z_range=self.z_range)
###MEI
if (self.datafile != None):
print "\nUsing --> " + self.datafile
data = u.import_matprops(self.datafile)
if len(data) == 0:
print "ERROR: no matprops plot data."
exit(1)
else:
data = u.query(point_list, self.cvm, elevation=1)
tmp = []
for matprop in data:
self.vplist.append(matprop.vp)
self.vslist.append(matprop.vs)
self.rholist.append(matprop.density)
## create the blob
if (self.datafile == None): ## save an external copy of matprops
b = {
'vp': float(matprop.vp),
'vs': float(matprop.vs),
'density': float(matprop.density)
}
tmp.append(b)
if (self.datafile == None):
blob = {'matprops': tmp}
u.export_matprops(blob, self.filename)
u.export_metadata(self.meta, self.filename)
def getplotvals(self):
point_list = []
# Generate the list of points.
# for i in xrange(int(self.startingpoint.depth), int(self.todepth + 1), int(self.spacing)):
self.meta['depth'] = []
for i in np.arange(self.startingpoint.depth, self.todepth + 1,
self.spacing):
point_list.append(
Point(self.startingpoint.longitude,
self.startingpoint.latitude, i))
self.meta['depth'].append(i)
u = UCVM(install_dir=self.installdir, config_file=self.configfile)
if (self.datafile != None):
print "\nUsing --> " + self.datafile
data = u.import_matprops(self.datafile)
if len(data) == 0:
print "ERROR: no matprops plot data."
exit(1)
else:
data = u.query(point_list, self.cvm)
# print "NUMBER of data found ", len(data)
tmp = []
for matprop in data:
self.vplist.append(matprop.vp)
self.vslist.append(matprop.vs)
self.rholist.append(matprop.density)
## create the blob
if (self.datafile == None): ## save an external copy of matprops
b = {
'vp': float(matprop.vp),
'vs': float(matprop.vs),
'density': float(matprop.density)
}
tmp.append(b)
if (self.datafile == None):
blob = {'matprops': tmp}
u.export_matprops(blob, self.filename)
u.export_metadata(self.meta, self.filename)
def plot(self):
self.installdir = None
if 'installdir' in self.meta:
self.installdir = self.meta['installdir']
self.configfile = None
if 'configfile' in self.meta:
self.configfile = self.meta['configfile']
if 'color' in self.meta:
color_scale = self.meta['color']
if 'gate' in self.meta:
scale_gate = int(self.meta['gate'])
else:
scale_gate = None
if color_scale == "b" and scale_gate is None:
scale_gate = 2.5
if self.startingpoint.description == None:
location_text = ""
else:
location_text = self.startingpoint.description + " "
if 'data_type' in self.meta:
mproperty = self.meta['data_type']
else:
mproperty = "vs"
# Gets the better CVM description if it exists.
try:
cvmdesc = UCVM_CVMS[self.cvm]
except:
cvmdesc = self.cvm
if 'title' in self.meta:
title = self.meta['title']
else:
title = "%s%s Cross Section from (%.2f, %.2f) to (%.2f, %.2f)" % (location_text, cvmdesc, self.startingpoint.longitude, \
self.startingpoint.latitude, self.endingpoint.longitude, self.endingpoint.latitude)
self.meta['title'] = title
self.getplotvals(mproperty)
# Call the plot object.
p = Plot(None, None, None, None, 10, 10)
plt.axes([0.1, 0.7, 0.8, 0.25])
# Figure out which is upper-right and bottom-left.
ur_lat = self.startingpoint.latitude if self.startingpoint.latitude > self.endingpoint.latitude else self.endingpoint.latitude
ur_lon = self.startingpoint.longitude if self.startingpoint.longitude > self.endingpoint.longitude else self.endingpoint.longitude
ll_lat = self.startingpoint.latitude if self.startingpoint.latitude < self.endingpoint.latitude else self.endingpoint.latitude
ll_lon = self.startingpoint.longitude if self.startingpoint.longitude < self.endingpoint.longitude else self.endingpoint.longitude
# Add 1% to each for good measure.
ur_lat = ur_lat + 0.03 * ur_lat
ur_lon = ur_lon - 0.015 * ur_lon
ll_lat = ll_lat - 0.03 * ll_lat
ll_lon = ll_lon + 0.015 * ll_lon
# Plot map up top.
m = basemap.Basemap(projection='cyl', llcrnrlat=ll_lat, urcrnrlat=ur_lat, \
llcrnrlon=ll_lon, urcrnrlon=ur_lon, \
resolution='f', anchor='C')
lat_ticks = np.arange(ll_lat, ur_lat + 0.1, (ur_lat - ll_lat))
lon_ticks = np.arange(ll_lon, ur_lon + 0.1, (ur_lon - ll_lon))
m.drawparallels(lat_ticks, linewidth=1.0, labels=[1, 0, 0, 0])
m.drawmeridians(lon_ticks, linewidth=1.0, labels=[0, 0, 0, 1])
m.drawstates()
m.drawcountries()
m.drawcoastlines()
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='brown', lake_color='aqua')
m.plot([self.startingpoint.longitude, self.endingpoint.longitude],
[self.startingpoint.latitude, self.endingpoint.latitude])
valign1 = "top"
valign2 = "bottom"
if self.endingpoint.latitude < self.startingpoint.latitude:
valign1 = "bottom"
valign2 = "top"
plt.text(self.startingpoint.longitude, self.startingpoint.latitude, \
'[S] %.1f, %.1f' % (self.startingpoint.longitude, self.startingpoint.latitude), \
color='k', horizontalalignment="center", verticalalignment=valign1)
plt.text(self.endingpoint.longitude, self.endingpoint.latitude, \
'[E] %.1f, %.1f' % (self.endingpoint.longitude, self.endingpoint.latitude), \
color='k', horizontalalignment="center", verticalalignment=valign2)
plt.axes([0.05, 0.18, 0.9, 0.54])
datapoints = np.arange(self.num_x * self.num_y,
dtype=np.float32).reshape(
self.num_y, self.num_x)
for y in xrange(0, self.num_y):
for x in xrange(0, self.num_x):
if self.datafile != None:
datapoints[y][x] = self.materialproperties[y][
x].getProperty(mproperty)
elif mproperty != "poisson":
datapoints[y][x] = self.materialproperties[y][
x].getProperty(mproperty)
else:
if self.materialproperties[y][
x].vp == 0 or self.materialproperties[y][
x].vs == 0.0:
datapoints[y][x] = 0.0
else:
datapoints[y][x] = self.materialproperties[y][
x].getProperty("vp") / self.materialproperties[y][
x].getProperty("vs")
u = UCVM(install_dir=self.installdir, config_file=self.configfile)
myInt = 1000
newdatapoints = datapoints / myInt
self.max_val = np.nanmax(newdatapoints)
self.min_val = np.nanmin(newdatapoints)
self.mean_val = np.mean(newdatapoints)
BOUNDS = u.makebounds()
TICKS = u.maketicks()
if mproperty == "vp":
BOUNDS = [bound * 1.7 for bound in BOUNDS]
TICKS = [tick * 1.7 for tick in TICKS]
# Set default colormap and range
colormap = basemap.cm.GMT_seis
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
umax = round(self.max_val)
if (umax < 5):
umax = 5
umin = round(self.min_val)
if color_scale == "s":
colormap = basemap.cm.GMT_seis
norm = mcolors.Normalize(vmin=0, vmax=umax)
elif color_scale == "s_r":
colormap = basemap.cm.GMT_seis_r
norm = mcolors.Normalize(vmin=0, vmax=umax)
elif color_scale == "sd":
BOUNDS = u.makebounds(self.min_val,
self.max_val,
5,
self.mean_val,
substep=5)
colormap = basemap.cm.GMT_seis
TICKS = u.maketicks(self.min_val, self.max_val, 5)
norm = mcolors.Normalize(vmin=self.min_val, vmax=self.max_val)
elif color_scale == "b":
C = []
for bound in BOUNDS:
if bound < scale_gate:
C.append("grey")
else:
C.append("red")
colormap = mcolors.ListedColormap(C)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == 'd':
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis,
len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == 'd_r':
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis_r,
len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == 'dd':
BOUNDS = u.makebounds(self.min_val,
self.max_val,
5,
self.mean_val,
substep=5)
TICKS = u.maketicks(self.min_val, self.max_val, 5)
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis,
len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
else:
print "ERROR: unknown option for colorscale."
## MEI, TODO this is a temporary way to generate an output of a cross_section input file
if (self.datafile == None):
self.meta['num_x'] = self.num_x
self.meta['num_y'] = self.num_y
self.meta['datapoints'] = datapoints.size
self.meta['max'] = np.asscalar(self.max_val)
self.meta['min'] = np.asscalar(self.min_val)
self.meta['mean'] = np.asscalar(self.mean_val)
self.meta['lon_list'] = self.lon_list
self.meta['lat_list'] = self.lat_list
self.meta['depth_list'] = self.depth_list
if self.filename:
u.export_metadata(self.meta, self.filename)
u.export_binary(datapoints, self.filename)
else:
#https://stackoverflow.com/questions/2257441/random-string-generation-with-upper-case-letters-and-digits-in-python
rnd = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.digits)
for _ in range(6))
f = "cross_section" + rnd
u.export_metadata(self.meta, f)
u.export_binary(datapoints, f)
img = plt.imshow(newdatapoints, cmap=colormap, norm=norm)
plt.xticks([0,self.num_x/2,self.num_x], ["[S] %.3f" % self.startingpoint.longitude, \
"%.3f" % ((float(self.endingpoint.longitude) + float(self.startingpoint.longitude)) / 2), \
"[E] %.3f" % self.endingpoint.longitude])
plt.yticks([0,self.num_y/2,self.num_y], ["%.2f" % (self.startingdepth/1000), \
"%.2f" % (self.startingdepth+ ((self.todepth-self.startingdepth)/2)/1000), \
"%.2f" % (self.todepth / 1000)])
plt.title(title)
cax = plt.axes([0.1, 0.1, 0.8, 0.02])
cbar = plt.colorbar(img,
cax=cax,
orientation='horizontal',
ticks=TICKS,
spacing='regular')
if mproperty != "poisson":
cbar.set_label(mproperty.title() + " (km/s)")
else:
cbar.set_label("Vp/Vs")
if self.filename:
plt.savefig(self.filename)
else:
plt.show()
def plot(self, horizontal_label=None):
if self.upperleftpoint.description == None:
location_text = ""
else:
location_text = self.upperleftpoint.description + " "
if 'data_type' in self.meta:
mproperty = self.meta['data_type']
else:
mproperty = "vs"
scale_gate = None
if 'color' in self.meta:
color_scale = self.meta['color']
if 'gate' in self.meta:
scale_gate = float(self.meta['gate'])
if color_scale == "b" and scale_gate is None:
scale_gate = 2.5
# Gets the better CVM description if it exists.
try:
cvmdesc = UCVM_CVMS[self.cvm]
except:
cvmdesc = self.cvm
if 'title' in self.meta:
title = self.meta['title']
else:
title = "%s%s Horizontal Slice at %.0fm" % (
location_text, cvmdesc, self.upperleftpoint.depth)
self.meta['title'] = title
self.getplotvals(mproperty)
# Call the plot object.
p = Plot(title, "", "", None, 10, 10)
u = UCVM(install_dir=self.installdir, config_file=self.configfile)
BOUNDS = u.makebounds()
TICKS = u.maketicks()
m = basemap.Basemap(projection='cyl', llcrnrlat=self.bottomrightpoint.latitude, \
urcrnrlat=self.upperleftpoint.latitude, \
llcrnrlon=self.upperleftpoint.longitude, \
urcrnrlon=self.bottomrightpoint.longitude, \
resolution='f', anchor='C')
lat_ticks = np.arange(self.bottomrightpoint.latitude,
self.upperleftpoint.latitude + 0.1,
self.plot_height / 2)
lon_ticks = np.arange(self.upperleftpoint.longitude,
self.bottomrightpoint.longitude + 0.1,
self.plot_width / 2)
m.drawparallels(lat_ticks, linewidth=1.0, labels=[1, 0, 0, 0])
m.drawmeridians(lon_ticks, linewidth=1.0, labels=[0, 0, 0, 1])
m.drawstates()
m.drawcountries()
alons = np.arange(self.upperleftpoint.longitude,
self.bottomrightpoint.longitude, self.spacing)
alats = np.arange(self.bottomrightpoint.latitude,
self.upperleftpoint.latitude, self.spacing)
lons = np.linspace(self.upperleftpoint.longitude,
self.bottomrightpoint.longitude - self.spacing,
self.num_x - 1)
lats = np.linspace(self.bottomrightpoint.latitude,
self.upperleftpoint.latitude - self.spacing,
self.num_y - 1)
# Get the properties.
datapoints = np.arange(self.num_x * self.num_y,
dtype=np.float32).reshape(
self.num_y, self.num_x)
nancnt = 0
zerocnt = 0
negcnt = 0
print("total cnt is ", self.num_x * self.num_y)
for i in xrange(0, self.num_y):
for j in xrange(0, self.num_x):
if (self.datafile != None):
datapoints[i][j] = self.materialproperties[i][
j].getProperty(mproperty)
elif mproperty != "poisson":
if color_scale == "sd" or color_scale == "sd_r":
datapoints[i][j] = self.materialproperties[i][
j].getProperty(mproperty)
if (datapoints[i][j] == -1):
datapoints[i][j] = np.nan
nancnt = nancnt + 1
##to have blank background
## if (datapoints[i][j] == 0) :
## datapoints[i][j]=np.nan
## zerocnt=zerocnt+1
##
else:
datapoints[i][j] = self.materialproperties[i][
j].getProperty(mproperty)
if (datapoints[i][j] == 0):
# KEEP 0 as 0 datapoints[i][j]=np.nan
zerocnt = zerocnt + 1
if (datapoints[i][j] < 0):
negcnt = negcnt + 1
if (datapoints[i][j] == -1):
datapoints[i][j] = np.nan
nancnt = nancnt + 1
else:
datapoints[i][j] = u.poisson(
self.materialproperties[i][j].vs,
self.materialproperties[i][j].vp)
# print (" total number of nancnt is ", nancnt)
# print (" total number of zerocnt is ", zerocnt)
# print (" total number of negcnt is ", negcnt)
myInt = 1000
if mproperty == "poisson": ## no need to reduce.. should also be using sd or dd
myInt = 1
if color_scale == "s":
color_scale = "sd"
elif color_scale == "d":
color_scale = "dd"
newdatapoints = datapoints / myInt
newmax_val = np.nanmax(newdatapoints)
newmin_val = np.nanmin(newdatapoints)
newmean_val = np.mean(newdatapoints)
self.max_val = np.nanmax(datapoints)
self.min_val = np.nanmin(datapoints)
self.mean_val = np.mean(datapoints)
if color_scale == "s":
colormap = basemap.cm.GMT_seis
norm = mcolors.Normalize(vmin=BOUNDS[0],
vmax=BOUNDS[len(BOUNDS) - 1])
elif color_scale == "s_r":
colormap = basemap.cm.GMT_seis_r
norm = mcolors.Normalize(vmin=BOUNDS[0],
vmax=BOUNDS[len(BOUNDS) - 1])
elif color_scale == "sd":
BOUNDS = u.makebounds(newmin_val,
newmax_val,
5,
newmean_val,
substep=5)
# colormap = basemap.cm.GMT_globe
colormap = basemap.cm.GMT_seis
TICKS = u.maketicks(newmin_val, newmax_val, 5)
norm = mcolors.Normalize(vmin=BOUNDS[0],
vmax=BOUNDS[len(BOUNDS) - 1])
elif color_scale == "b":
C = []
for bound in BOUNDS:
if bound < scale_gate:
C.append("grey")
else:
C.append("red")
colormap = mcolors.ListedColormap(C)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == "d":
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis,
len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == "d_r":
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis_r,
len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
elif color_scale == 'dd':
BOUNDS = u.makebounds(newmin_val,
newmax_val,
5,
newmean_val,
substep=5,
all=True)
TICKS = u.maketicks(newmin_val, newmax_val, 5)
colormap = pycvm_cmapDiscretize(basemap.cm.GMT_seis,
len(BOUNDS) - 1)
# colormap = pycvm_cmapDiscretize(basemap.cm.GMT_globe, len(BOUNDS) - 1)
norm = mcolors.BoundaryNorm(BOUNDS, colormap.N)
else:
print "ERROR: unknown option for colorscale."
if (self.datafile == None):
self.meta['num_x'] = self.num_x
self.meta['num_y'] = self.num_y
self.meta['datapoints'] = datapoints.size
self.meta['max'] = np.asscalar(self.max_val)
self.meta['min'] = np.asscalar(self.min_val)
self.meta['mean'] = np.asscalar(self.mean_val)
self.meta['lon_list'] = lons.tolist()
self.meta['lat_list'] = lats.tolist()
if self.filename:
u.export_metadata(self.meta, self.filename)
u.export_binary(datapoints, self.filename)
## reduce the datapoints before passing in..
t = m.transform_scalar(newdatapoints, lons, lats, len(lons), len(lats))
img = m.imshow(t, cmap=colormap, norm=norm)
# print "MIN is ", np.nanmin(datapoints)
# print "MAX is ", np.nanmax(datapoints)
# img=m.scatter(xlist, ylist, c=dlist, cmap=colormap, norm=norm, s=1, edgecolor='',marker='o')
# img=m.scatter(xcoords, ycoords, c=datapoints, cmap=colormap, norm=norm, s=1, edgecolor='',marker='o')
m.drawcoastlines()
cax = plt.axes([0.125, 0.05, 0.775, 0.02])
cbar = plt.colorbar(img,
cax=cax,
orientation='horizontal',
spacing='proportional',
ticks=TICKS)
if mproperty != "poisson":
if horizontal_label == None:
cbar.set_label(mproperty.title() + " (km/s)")
else:
cbar.set_label(horizontal_label)
else:
cbar.set_label("Poisson(Vs,Vp)")
if self.filename:
plt.savefig(self.filename)
## MEI, TODO p.savehtml("show.html")
else:
plt.show()