def calculate_geomap(self, interpdata=None, plot=True):
'''
Args:
interpdata:
plot:
Returns:
'''
if interpdata:
geomap, fault = gp.compute_model_at(self.surface_coordinates[0],
interpdata)
else:
geomap, fault = gp.compute_model_at(self.surface_coordinates[0],
self.interp_data)
geomap = geomap[0].reshape(
self.dem_zval.shape) # resolution of topo gives much better map
geomap = np.flip(
geomap,
axis=0) #to match the orientation of the other plotting options
if plot:
plt.imshow(geomap,
origin="lower",
cmap=gp.plotting.colors.cmap,
norm=gp.plotting.colors.norm) # set extent
plt.title("Geological map", fontsize=15)
return geomap
def render_frame(self, outfile=None):
if self.cmap == None:
plotter = gempy.PlotData2D(self.model._geo_data)
self.cmap = plotter._cmap
self.norm = plotter._norm
self.lot = plotter._color_lot
lith_block, fault_block = gempy.compute_model_at(
self.depth_grid, self.model)
block = lith_block[0].reshape(
(self.associated_calibration.calibration_data['y_lim'][1] -
self.associated_calibration.calibration_data['y_lim'][0],
self.associated_calibration.calibration_data['x_lim'][1] -
self.associated_calibration.calibration_data['x_lim'][0]))
h = (self.associated_calibration.calibration_data['y_lim'][1] -
self.associated_calibration.calibration_data['y_lim'][0]) / 100.0
w = (self.associated_calibration.calibration_data['x_lim'][1] -
self.associated_calibration.calibration_data['x_lim'][0]) / 100.0
fig = plt.figure(figsize=(w, h), dpi=100, frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.pcolormesh(block, cmap=self.cmap, norm=self.norm)
if outfile == None:
plt.show()
plt.close()
else:
plt.savefig(outfile, pad_inches=0)
plt.close(fig)
def get_surflith(dem, dema, interp_data, output_filename='DEMxyz.csv'):
'''Reshape DEM and use it to compute the lithology values of the GemPy model at the land surface.
Returns an array of lith values at the surface z elevation for each xy point.
dem: dem object returned by importDEM() or dem = gdal.Open(filename)
dema: dem array returned by importDEM() or dema = dem.ReadAsArray()
interp_data: interpolated data returned by gempy.InterpolatorData()
output_filename: string to name gdal's output csv file (can be a throw-away - not used again)
returns:
surflith: an array of lith values at the surface z elevation for each xy point, dim (yres,xres)'''
#Get an array with xyz values from the DEM:
#can this be streamlined to avoid having to export and re-import?
translate_options = gdal.TranslateOptions(
options=['format'], format="XYZ") #set options for gdal.Translate()
gdal.Translate(
output_filename, dem, options=translate_options
) #convert dem to a csv with one column of points, each with an xyz value
xyz = pn.read_csv(output_filename, header=None,
sep=' ') #read xyz csv with pandas
demlist = xyz.as_matrix(
) #convert to np array of (x,y,z) values with dim (ncol*nrow, 3)
#Format the geologic data:
surflith, fault2 = gp.compute_model_at(
demlist, interp_data
) #compute the model values at the locations specified (aka the land surface) (why is fault a required output?)
surflith = surflith[0].reshape(
dema.shape
) #reshape lith block (a list) to an array with same dimensions as dem (yres,xres,zres) (note: xres*yres must equal length of lith)
#now we have a discretized array with the same resolution as the dem, with a value for the lithology at the surface elevation for each xy point
return surflith
def plot_map(self, iteration=1, **kwargs):
self._change_input_data(iteration)
# geomap = self.topography.calculate_geomap(interpdata = self.interp_data, plot=True)
geomap, faultmap = gp.compute_model_at(
self.topography.surface_coordinates[0], self.interp_data)
# gp.plotting.plot_map(geomap)
gp.plotting.plot_map(self.geo_data,
geomap=geomap[0].reshape(
self.topography.dem_zval.shape),
**kwargs)
def all_post_maps(self):
all_maps = []
for i in range(0, self.n_iter):
# print(i)
self._change_input_data(i)
# geomap = self.topography.calculate_geomap(interpdata = self.interp_data, plot=True)
geomap, faultmap = gp.compute_model_at(
self.topography.surface_coordinates[0], self.interp_data)
all_maps.insert(i, geomap[0])
return all_maps
def test_rgeomod_integration(theano_f):
geo_data=gp.create_data(extent=[612000, 622000, 2472000, 2480000, -1000, 1000],
resolution=[50, 50, 50],
path_f=input_path+"/gempy_foliations.csv",
path_i=input_path+"/gempy_interfaces.csv")
formation_order = ["Unit4", "Unit3", "Unit2", "Unit1"]
gp.set_series(geo_data, {"Default series": formation_order},
order_formations = formation_order, verbose=1)
gp.plot_data(geo_data, direction="z")
#interp_data = gp.InterpolatorData(geo_data, compile_theano=True)
interp_data = theano_f
interp_data.update_interpolator(geo_data)
lith_block, fault_block = gp.compute_model(interp_data)
print("3-D geological model calculated.")
gp.plot_section(geo_data, lith_block[0], 25, direction='y', plot_data=False)
#plt.savefig("../data/cross_section_NS_25.pdf", bbox_inches="tight")
gp.plot_section(geo_data, lith_block[0], 25, direction='x', plot_data=False)
#plt.savefig("../data/cross_section_EW_25.pdf", bbox_inches="tight")
vertices, simplices = gp.get_surfaces(interp_data, potential_lith=lith_block[1], step_size=2)
fig = plt.figure(figsize=(13,10))
ax = fig.add_subplot(111, projection='3d')
cs = ["lightblue", "pink", "lightgreen", "orange"]
for i in range(4):
surf = ax.plot_trisurf(vertices[i][:,0], vertices[i][:,1], vertices[i][:,2],
color=cs[i], linewidth=0, alpha=0.65, shade=False)
#plt.savefig("../data/surfaces_3D.pdf", bbox_inches="tight")
# try:
# gp.plot_surfaces_3D(geo_data, vertices, simplices)
# except NameError:
# print("3-D visualization library vtk not installed.")
# load the digital elevation model
geotiff_filepath = input_path+"/dome_sub_sub_utm.tif"
raster = gdal.Open(geotiff_filepath)
dtm = raster.ReadAsArray()
dtmp = plt.imshow(dtm, origin='upper', cmap="viridis");
plt.title("Digital elevation model");
plt.colorbar(dtmp, label="Elevation [m]");
plt.savefig(input_path+"/DTM.pdf")
# To be able to use gempy plotting functionality we need to create a dummy geo_data object with the
# resoluion we want. In this case resolution=[339, 271, 1]
import copy
geo_data_dummy = copy.deepcopy(geo_data)
geo_data_dummy.resolution = [339, 271, 1]
# convert the dtm to a gempy-suitable raveled grid
points = rgeomod.convert_dtm_to_gempy_grid(raster, dtm)
# Now we can use the function `compute_model_at` to get the lithology values at a specific location:
# In[17]:
# interp_data_geomap = gp.InterpolatorInput(geo_data, dtype="float64")
lith_block, fault_block = gp.compute_model_at(points, interp_data)
# <div class="alert alert-info">
# **Your task:** Create a visual representation of the geological map in a 2-D plot (note: result is also again saved to the `../data`-folder):
# </div>
#
# And here **the geological map**:
# In[18]:
gp.plot_section(geo_data_dummy, lith_block[0], 0, direction='z', plot_data=False)
plt.title("Geological map");
#plt.savefig("../geological_map.pdf")
# ### Export the map for visualization in GoogleEarth
# <div class="alert alert-info">
# **Your task:** Execute the following code to export a GeoTiff of the generated geological map, as well as `kml`-files with your picked points inside the data folder. Open these files in GoogleEarth and inspect the generated map:
# </div>
#
#
# <div class="alert alert-warning">
# **Note (1)**: Use the normal `File -> Open..` dialog in GoogleEarth to open the data - no need to use the `Import` method, as the GeoTiff contains the correct coordinates in the file.
# </div>
#
#
# <div class="alert alert-warning">
# **Note (2)**: For a better interpretation of the generated map, use the transparency feature (directly after opening the map, or using `right-click -> Get Info` on the file).
# </div>
# In[19]:
geo_map = lith_block[0].copy().reshape((339,271))
geo_map = geo_map.astype('int16') # change to int for later use
# In[20]:
rgeomod.export_geotiff(input_path+"/geomap.tif", geo_map, gp.plotting.colors.cmap, geotiff_filepath)
# Export the interface data points:
# In[21]:
t = input_path+"/templates/ge_template_raw_interf.xml"
pt = input_path+"/templates/ge_placemark_template_interf.xml"
rgeomod.gempy_export_points_to_kml(input_path, geo_data, pt, t, gp.plotting.colors.cmap)
# Export the foliation data:
t = input_path+"/templates/ge_template_raw_fol.xml"
pt = input_path+"/templates/ge_placemark_template_fol.xml"
rgeomod.gempy_export_fol_to_kml(input_path+"/dips.kml", geo_data, pt, t)
def render_frame(self, depth, outfile=None):
t0 = time.clock()
self.update_grid(depth)
if self.cmap is None:
self.set_cmap()
if self.lock is not None:
self.lock.acquire()
sol = gempy.compute_model_at(self.depth_grid, self.model)
#lith_block, fault_block =
self.lock.release()
else:
sol = gempy.compute_model_at(self.depth_grid, self.model)
scalar_field = sol.scalar_field_lith.reshape(
(self.output_res[1], self.output_res[0]))
block = sol.lith_block.reshape(
(self.output_res[1], self.output_res[0]))
h = self.associated_calibration.calibration_data['scale_factor'] * (
self.output_res[1]) / 100.0
w = self.associated_calibration.calibration_data['scale_factor'] * (
self.output_res[0]) / 100.0
fig = plt.figure(figsize=(w, h), dpi=100, frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.pcolormesh(block, cmap=self.cmap, norm=self.norm)
if self.show_faults is True:
plt.contour(sol.fault_blocks[0].reshape(
(self.output_res[1], self.output_res[0])),
levels=self.fault_contours,
linewidths=3.0,
colors=[(1.0, 1.0, 1.0, 1.0)])
if self.contours is True:
x = range(self.output_res[0])
y = range(self.output_res[1])
z = self.depth_grid.reshape(
(self.output_res[1], self.output_res[0], 3))[:, :, 2]
sub_contours = plt.contour(x,
y,
z,
levels=self.sub_contours,
linewidths=0.5,
colors=[(0, 0, 0, 0.8)])
main_contours = plt.contour(x,
y,
z,
levels=self.main_contours,
linewidths=1.0,
colors=[(0, 0, 0, 1.0)])
# plt.contour(lith_block[1].reshape((self.output_res[1], self.output_res[0])) levels=main_levels, linewidths=1.0, colors=[(0, 0, 0, 1.0)])
plt.clabel(main_contours, inline=0, fontsize=15, fmt='%3.0f')
if self.scalar_contours is True:
x = range(self.output_res[0])
y = range(self.output_res[1])
z = scalar_field
sub_contours = plt.contour(x,
y,
z,
levels=self.scalar_sub_contours,
linewidths=0.5,
colors=[(0, 0, 0, 0.8)])
main_contours = plt.contour(x,
y,
z,
levels=self.scalar_main_contours,
linewidths=1.0,
colors=[(0, 0, 0, 1.0)])
# plt.contour(lith_block[1].reshape((self.output_res[1], self.output_res[0])) levels=main_levels, linewidths=1.0, colors=[(0, 0, 0, 1.0)])
plt.clabel(main_contours, inline=0, fontsize=15, fmt='%3.0f')
if outfile == None:
plt.show()
plt.close()
else:
plt.savefig(outfile, pad_inches=0)
plt.close(fig)
t1 = time.clock()
if self.show_framerate is True:
print("frame took " + str(t1 - t0) + " s")
