def case_1a(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ define JIGSAW geometry
geom.mshID = "euclidean-mesh"
geom.ndims = +3
geom.vert3 = np.array([ # list of xy "node" coordinates
((0, 0, 0), 0),
((3, 0, 0), 0),
((3, 3, 0), 0),
((0, 3, 0), 0),
((0, 0, 3), 0),
((3, 0, 3), 0),
((3, 3, 3), 0),
((0, 3, 3), 0)],
dtype=geom.VERT3_t)
geom.tria3 = np.array([ # list of "tria" between points
((0, 1, 2), 0),
((0, 2, 3), 0),
((4, 5, 6), 0),
((4, 6, 7), 0),
((0, 1, 5), 0),
((0, 5, 4), 0),
((1, 2, 6), 0),
((1, 6, 5), 0),
((2, 3, 7), 0),
((2, 7, 6), 0),
((3, 7, 4), 0),
((3, 4, 0), 0)],
dtype=geom.TRIA3_t)
#------------------------------------ build mesh via JIGSAW!
print("Call libJIGSAW: case 1a.")
opts.hfun_hmax = 0.08 # push HFUN limits
opts.mesh_dims = +3 # 3-dim. simplexes
opts.mesh_top1 = True # for sharp feat's
opts.geom_feat = True
jigsawpy.lib.jigsaw(opts, geom, mesh)
scr3 = jigsawpy.triscr3( # "quality" metric
mesh.point["coord"],
mesh.tria4["index"])
print("Saving case_1a.vtk file.")
jigsawpy.savevtk(os.path.join(
dst_path, "case_1a.vtk"), mesh)
return
def case_8_(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ make mesh using JIGSAW
print("Call libJIGSAW: case 8a.")
jigsawpy.loadmsh(os.path.join(src_path, "eight.msh"), geom)
opts.hfun_hmax = 0.04 # set HFUN limits
opts.mesh_kern = "delfront" # DELFRONT kernel
opts.mesh_dims = +3
jigsawpy.lib.jigsaw(opts, geom, mesh)
print("Saving case_8a.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_8a.vtk"), geom)
print("Saving case_8b.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_8b.vtk"), mesh)
return
def case_7_(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ make mesh using JIGSAW
print("Call libJIGSAW: case 7a.")
jigsawpy.loadmsh(os.path.join(src_path, "wheel.msh"), geom)
opts.hfun_hmax = 0.03 # set HFUN limits
opts.mesh_kern = "delfront" # DELFRONT kernel
opts.mesh_dims = +2
opts.geom_feat = True
opts.mesh_top1 = True
opts.mesh_top2 = True
jigsawpy.lib.jigsaw(opts, geom, mesh)
print("Saving case_7a.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_7a.vtk"), geom)
print("Saving case_7b.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_7b.vtk"), mesh)
return
def make_mesh():
opts = jigsawpy.jigsaw_jig_t() # jigsaw data structures
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
opts.geom_file = "tmp/geom.msh" # setup jigsaw files
opts.jcfg_file = "tmp/opts.jig"
opts.mesh_file = "out/mesh.msh"
geom.mshID = "ellipsoid-mesh" # a simple "unit" sphere
geom.radii = np.ones(+3)
jigsawpy.savemsh(opts.geom_file, geom)
opts.verbosity = +1 # setup user-defined opt
opts.optm_iter = +512
opts.optm_qtol = +1.E-08
opts.optm_kern = "odt+dqdx"
# opts.optm_kern = "cvt+dqdx"
ttic = time.time()
jigsawpy.cmd.icosahedron(opts, 6, mesh) # mesh with n bisections
# keep = mesh.tria3["IDtag"] == +1 # only keep single face?
# mesh.tria3 = mesh.tria3[keep]
ttoc = time.time()
print("CPUSEC =", (ttoc - ttic))
jigsawpy.savevtk("mesh.vtk", mesh) # to open in paraview...
return
def case_0a(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ define JIGSAW geometry
geom.mshID = "euclidean-mesh"
geom.ndims = +2
geom.vert2 = np.array([ # list of xy "node" coordinate
((0, 0), 0), # outer square
((9, 0), 0),
((9, 9), 0),
((0, 9), 0),
((4, 4), 0), # inner square
((5, 4), 0),
((5, 5), 0),
((4, 5), 0)],
dtype=geom.VERT2_t)
geom.edge2 = np.array([ # list of "edges" between vert
((0, 1), 0), # outer square
((1, 2), 0),
((2, 3), 0),
((3, 0), 0),
((4, 5), 0), # inner square
((5, 6), 0),
((6, 7), 0),
((7, 4), 0)],
dtype=geom.EDGE2_t)
#------------------------------------ build mesh via JIGSAW!
print("Call libJIGSAW: case 0a.")
opts.hfun_hmax = 0.05 # push HFUN limits
opts.mesh_dims = +2 # 2-dim. simplexes
opts.optm_qlim = +.95
opts.mesh_top1 = True # for sharp feat's
opts.geom_feat = True
jigsawpy.lib.jigsaw(opts, geom, mesh)
scr2 = jigsawpy.triscr2( # "quality" metric
mesh.point["coord"],
mesh.tria3["index"])
print("Saving case_0a.vtk file.")
jigsawpy.savevtk(os.path.join(
dst_path, "case_0a.vtk"), mesh)
return
def case_6_(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
geom = jigsawpy.jigsaw_msh_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ setup files for JIGSAW
opts.geom_file = \
os.path.join(src_path, "piece.msh")
opts.jcfg_file = \
os.path.join(dst_path, "piece.jig")
opts.mesh_file = \
os.path.join(dst_path, "piece.msh")
#------------------------------------ make mesh using JIGSAW
jigsawpy.loadmsh(opts.geom_file, geom)
print("Saving case_6a.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_6a.vtk"), geom)
opts.hfun_hmax = 0.03 # set HFUN limits
opts.mesh_kern = "delfront" # DELFRONT kernel
opts.mesh_dims = +2
jigsawpy.cmd.jigsaw(opts, mesh)
print("Saving case_6b.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_6b.vtk"), mesh)
#------------------------------------ make mesh using JIGSAW
opts.hfun_hmax = 0.03 # set HFUN limits
opts.mesh_kern = "delfront" # DELFRONT kernel
opts.mesh_dims = +2
opts.geom_feat = True
opts.mesh_top1 = True
jigsawpy.cmd.jigsaw(opts, mesh)
print("Saving case_6c.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_6c.vtk"), mesh)
return
def setgeom():
geom = jigsawpy.jigsaw_msh_t()
poly = jigsawpy.jigsaw_msh_t()
#------------------------------------ define JIGSAW geometry
geom.mshID = "euclidean-mesh"
#------------------------------------ set watershed boundary
print("BUILDING MESH GEOM.")
filename = os.path.join(
"data",
"NHD_H_0204_HU4_Shape", "Shape", "WBDHU8.shp")
loadshp(filename, poly, filt_WDBHU8)
poly.point["coord"] *= np.pi / +180.
addpoly(geom, poly, +1)
#------------------------------------ approx. stream network
filename = os.path.join(
"data", "namerica_rivers", "narivs.shp")
loadshp(filename, poly, filt_narivs)
poly.point["coord"] *= np.pi / +180.
itag = innerto(poly.vert2["coord"], geom)
keep = np.logical_and.reduce((
itag[poly.edge2["index"][:, 0]] > +0,
itag[poly.edge2["index"][:, 1]] > +0
))
poly.edge2 = poly.edge2[keep]
addline(geom, poly, +1)
#------------------------------------ proj. to local 2-plane
proj = jigsawpy.jigsaw_prj_t()
proj.prjID = "stereographic"
proj.radii = FULL_SPHERE_RADIUS
proj.xbase = PROJ_CENTRE[0] * np.pi / +180.
proj.ybase = PROJ_CENTRE[1] * np.pi / +180.
jigsawpy.project(geom, proj, "fwd")
GEOM[0] = geom # save a "pointer"
return geom
def _jigsaw_hmat_worker(path, window, hmin, hmax, geom):
geom = None
raster = Raster(path)
x = raster.get_x(window)
y = raster.get_y(window)
_y = np.repeat(np.min(y), len(x))
_x = np.repeat(np.min(x), len(y))
_tx = utm.from_latlon(_y, x)[0]
_ty = np.flip(utm.from_latlon(y, _x)[1])
hmat = jigsaw_msh_t()
hmat.mshID = "euclidean-grid"
hmat.ndims = +2
hmat.xgrid = _tx.astype(jigsaw_msh_t.REALS_t)
hmat.ygrid = _ty.astype(jigsaw_msh_t.REALS_t)
hmat.value = np.flipud(
raster.get_values(band=1, window=window)
).astype(jigsaw_msh_t.REALS_t)
# init opts
opts = jigsaw_jig_t()
# additional configuration options
opts.verbosity = 1
opts.mesh_dims = 2
opts.hfun_scal = 'absolute'
opts.optm_tria = True
if hmin is not None:
opts.hfun_hmin = hmin
else:
opts.hfun_hmin = np.min(hmat.value)
if hmax is not None:
opts.hfun_hmax = hmax
else:
opts.hfun_hmax = np.max(hmat.value)
# output mesh
mesh = jigsaw_msh_t()
# call jigsaw to create local mesh
libsaw.jigsaw(
opts,
geom,
mesh,
hfun=hmat
)
breakpoint()
return mesh
def addline(geom, line, itag):
"""
ADDLINE: push new open polyline LINE to mst_t obj. GEOM.
The LINE.POINT + LINE.EDGE2 arrays are appended to GEOM.
The new edges are assigned ID = ITAG.
"""
# Authors: Darren Engwirda
temp = jigsawpy.jigsaw_msh_t()
temp.point = line.point
temp.edge2 = line.edge2
temp.edge2["IDtag"] = itag
zipmesh(temp) # ensure compressed
temp.edge2["index"] += geom.vert2.size
geom.point = np.concatenate(
(geom.vert2, temp.vert2), axis=0)
geom.edge2 = np.concatenate(
(geom.edge2, temp.edge2), axis=0)
return
def geom(self):
geom = jigsaw_msh_t()
geom.vert2 = self.vert2
geom.edge2 = self.edge2
geom.ndim = self.ndim
geom.mshID = self.mshID
return geom
def multipolygon_to_geom(multipolygon):
assert isinstance(multipolygon, MultiPolygon)
vert2 = list()
for polygon in multipolygon:
if np.all(
np.asarray(polygon.exterior.coords).flatten() == float('inf')):
msg = "PSLG seems to correspond to ellipsoidal mesh "
msg += "which has not yet been implemented."
raise NotImplementedError(msg)
for x, y in polygon.exterior.coords[:-1]:
vert2.append(((x, y), 0))
for interior in polygon.interiors:
for x, y in interior.coords[:-1]:
vert2.append(((x, y), 0))
vert2 = np.asarray(vert2, dtype=jigsaw_msh_t.VERT2_t)
# edge2
edge2 = list()
for polygon in multipolygon:
polygon = [polygon.exterior, *polygon.interiors]
for linear_ring in polygon:
_edge2 = list()
for i in range(len(linear_ring.coords)-2):
_edge2.append((i, i+1))
_edge2.append((_edge2[-1][1], _edge2[0][0]))
edge2.extend(
[(e0+len(edge2), e1+len(edge2)) for e0, e1 in _edge2])
edge2 = np.asarray(
[((e0, e1), 0) for e0, e1 in edge2], dtype=jigsaw_msh_t.EDGE2_t)
# geom
geom = jigsaw_msh_t()
geom.ndims = +2
geom.mshID = 'euclidean-mesh'
geom.vert2 = vert2
geom.edge2 = edge2
return geom
def setinit():
init = jigsawpy.jigsaw_msh_t()
#------------------------------------ set initial conditions
print("BUILDING MESH INIT.")
filename = os.path.join(HERE, "..", "delaware_60_30_5_2", "tmp",
"mesh.msh")
if os.path.isfile(filename): # load from init.
jigsawpy.loadmsh(filename, init)
else:
raise Exception("File not found: first run delaware_60_30_5_2"
" to form initial conditions!")
geom = copy.deepcopy(GEOM[0])
spac = copy.deepcopy(SPAC[0])
zipnear(init, geom, spac, near=+1.E+01)
return init
def setspac():
spac = jigsawpy.jigsaw_msh_t()
#------------------------------------ define spacing pattern
xmid = -76.5 * np.pi / 180.0
ymid = +39.5 * np.pi / 180.0
spac.mshID = "ellipsoid-grid"
spac.radii = np.full(
3, FULL_SPHERE_RADIUS, dtype=spac.REALS_t)
spac.xgrid = np.linspace(
-1. * np.pi, +1. * np.pi, 720)
spac.ygrid = np.linspace(
-.5 * np.pi, +.5 * np.pi, 361)
xmat, ymat = \
np.meshgrid(spac.xgrid[:] , spac.ygrid[:])
spac.value = +200. - 195. * np.exp(-(
+12.5 * (xmat - xmid) ** 2 +
+20.0 * (ymat - ymid) ** 2) ** 2)
return spac
def linegeo(line, nset, eset, nobj, last):
"""
LINEGEO: read a geoJSON line into a jigsaw msh_t object.
"""
# Authors: Darren Engwirda
npts = len(line) - 0
if (npts > 0):
#----------------------------------------- read LINE dataset
temp = jigsaw_msh_t()
temp.vert2 = np.zeros(
(npts + 0), dtype=temp.VERT2_t)
temp.edge2 = np.zeros(
(npts - 1), dtype=temp.EDGE2_t)
temp.edge2["IDtag"][:] = nobj
nobj = nobj + 1
indx = np.arange(0, npts - 1) + last
last = last + npts
temp.vert2["coord"] = line[+0::]
temp.edge2["index"][:, 0] = indx + 0
temp.edge2["index"][:, 1] = indx + 1
nset.append(temp.vert2)
eset.append(temp.edge2)
return nobj, last
def get_jigsaw_msh_t(self, **kwargs):
multipolygon = self.get_multipolygon(**kwargs)
vert2 = list()
for polygon in multipolygon:
if np.all(
np.asarray(polygon.exterior.coords).flatten() == float(
'inf')):
raise NotImplementedError("ellispoidal-mesh")
for x, y in polygon.exterior.coords[:-1]:
vert2.append(((x, y), 0))
for interior in polygon.interiors:
for x, y in interior.coords[:-1]:
vert2.append(((x, y), 0))
vert2 = np.asarray(vert2, dtype=jigsaw_msh_t.VERT2_t)
# edge2
edge2 = list()
for polygon in multipolygon:
polygon = [polygon.exterior, *polygon.interiors]
for linear_ring in polygon:
_edge2 = list()
for i in range(len(linear_ring.coords) - 2):
_edge2.append((i, i + 1))
_edge2.append((_edge2[-1][1], _edge2[0][0]))
edge2.extend([(e0 + len(edge2), e1 + len(edge2))
for e0, e1 in _edge2])
edge2 = np.asarray([((e0, e1), 0) for e0, e1 in edge2],
dtype=jigsaw_msh_t.EDGE2_t)
# geom
geom = jigsaw_msh_t()
geom.ndims = +2
geom.mshID = 'euclidean-mesh' if self._ellipsoid is None \
else 'ellipsoidal-mesh'
geom.vert2 = vert2
geom.edge2 = edge2
return geom
def jigsaw_driver(cellWidth, lon, lat):
'''
A function for building a jigsaw mesh
Parameters
----------
cellWidth : ndarray
The size of each cell in the resulting mesh as a function of space
lon, lat : ndarray
The lon. and lat. of each point in the cellWidth array
'''
# Authors
# -------
# Mark Petersen, Phillip Wolfram, Xylar Asay-Davis
# setup files for JIGSAW
opts = jigsawpy.jigsaw_jig_t()
opts.geom_file = 'mesh.msh'
opts.jcfg_file = 'mesh.jig'
opts.mesh_file = 'mesh-MESH.msh'
opts.hfun_file = 'mesh-HFUN.msh'
# save HFUN data to file
hmat = jigsawpy.jigsaw_msh_t()
hmat.mshID = 'ELLIPSOID-GRID'
hmat.xgrid = numpy.radians(lon)
hmat.ygrid = numpy.radians(lat)
hmat.value = cellWidth
jigsawpy.savemsh(opts.hfun_file, hmat)
# define JIGSAW geometry
geom = jigsawpy.jigsaw_msh_t()
geom.mshID = 'ELLIPSOID-MESH'
geom.radii = 6371.*numpy.ones(3, float)
jigsawpy.savemsh(opts.geom_file, geom)
# build mesh via JIGSAW!
mesh = jigsawpy.jigsaw_msh_t()
opts.hfun_scal = 'absolute'
opts.hfun_hmax = float("inf")
opts.hfun_hmin = 0.0
opts.mesh_dims = +2 # 2-dim. simplexes
opts.optm_qlim = 0.9375
opts.verbosity = +1
jigsawpy.cmd.jigsaw(opts)
def setinit():
init = jigsawpy.jigsaw_msh_t()
#------------------------------------ set initial conditions
# just an empty msh_t object!
return init
def mesh(self):
mesh = jigsaw_msh_t()
mesh.mshID = 'euclidean-mesh'
mesh.ndims = 2
mesh.vert2 = self.vert2
mesh.tria3 = self.tria3
mesh.quad4 = self.quad4
# mesh.hexa8 = self.hexa8
mesh.value = self.value
return mesh
def setgeom():
geom = jigsawpy.jigsaw_msh_t()
#------------------------------------ define JIGSAW geometry
geom.mshID = "ellipsoid-mesh"
geom.radii = np.full(3, FULL_SPHERE_RADIUS, dtype=geom.REALS_t)
return geom
def case_2_(src_path, dst_path):
opts = jigsawpy.jigsaw_jig_t()
mesh = jigsawpy.jigsaw_msh_t()
#------------------------------------ setup files for JIGSAW
opts.geom_file = \
os.path.join(src_path, "lakes.msh")
opts.jcfg_file = \
os.path.join(dst_path, "lakes.jig")
opts.mesh_file = \
os.path.join(dst_path, "lakes.msh")
#------------------------------------ make mesh using JIGSAW
opts.mesh_kern = "delaunay" # DELAUNAY kernel
opts.mesh_dims = +2
opts.mesh_top1 = True # mesh sharp feat.
opts.geom_feat = True
opts.optm_iter = +0
opts.hfun_hmax = 0.02
jigsawpy.cmd.jigsaw(opts, mesh)
print("Saving case_2a.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_2a.vtk"), mesh)
#------------------------------------ make mesh using JIGSAW
opts.mesh_kern = "delfront" # DELFRONT kernel
opts.mesh_dims = +2
opts.mesh_top1 = True # mesh sharp feat.
opts.geom_feat = True
opts.optm_iter = +0
opts.hfun_hmax = 0.02
jigsawpy.cmd.jigsaw(opts, mesh)
print("Saving case_2b.vtk file.")
jigsawpy.savevtk(os.path.join(dst_path, "case_2b.vtk"), mesh)
return
def setgeom():
geom = jigsawpy.jigsaw_msh_t()
#------------------------------------ define JIGSAW geometry
print("BUILDING MESH GEOM.")
geom.mshID = "ellipsoid-mesh"
geom.radii = np.full(+3, FULL_SPHERE_RADIUS, dtype=geom.REALS_t)
return geom
def _run_cmdsaw(self):
msg = f'_run_cmdsaw()'
self.logger.debug(msg)
# init tmpfiles
self.logger.debug(f'init tmpfiles')
mesh_file = tempfile.NamedTemporaryFile(prefix=tmpdir, suffix='.msh')
hmat_file = tempfile.NamedTemporaryFile(prefix=tmpdir, suffix='.msh')
geom_file = tempfile.NamedTemporaryFile(prefix=tmpdir, suffix='.msh')
jcfg_file = tempfile.NamedTemporaryFile(prefix=tmpdir, suffix='.jig')
# dump data to tempfiles
jigsawpy.savemsh(hmat_file.name, self.hfun)
jigsawpy.savemsh(geom_file.name, self.geom)
# init opts
opts = jigsaw_jig_t()
opts.mesh_file = mesh_file.name
opts.hfun_file = hmat_file.name
opts.geom_file = geom_file.name
opts.jcfg_file = jcfg_file.name
# additional configuration options
opts.verbosity = self.verbosity
opts.mesh_dims = +2 # NOTE: Hardcoded value
opts.hfun_scal = 'absolute'
opts.optm_tria = True # NOTE: Hardcoded value
opts.optm_qlim = self.optm_qlim
if self.hmin_is_absolute_limit:
opts.hfun_hmin = self.hmin
else:
opts.hfun_hmin = np.min(self.hfun.value)
if self.hmax_is_absolute_limit:
opts.hfun_hmax = self.hmax
else:
opts.hfun_hmax = np.max(self.hfun.value)
# init outputmesh
mesh = jigsaw_msh_t()
# call jigsaw
self.logger.debug('call cmdsaw')
jigsawpy.cmd.jigsaw(opts, mesh)
# cleanup temporary files
for tmpfile in (mesh_file, hmat_file, geom_file, jcfg_file):
del (tmpfile)
self.__output_mesh = mesh
def geom(self):
"""
This is the global geom
"""
try:
name = self.__geom_tmpfile.name
geom = jigsaw_msh_t()
loadmsh(name, geom)
return geom
except AttributeError:
# jigsawpy.msh_t.jigsaw_msh_t
if isinstance(self._geom, jigsaw_msh_t):
self._logger.debug('self.geom:AttributeError:jigsaw_msh_t')
self._geom.edge2 = geomesh.utils.edge2_from_msh_t(self._geom)
geom = self._geom
elif isinstance(self._geom, (Polygon, MultiPolygon)):
msg = 'self.geom:AttributeError:(Polygon, MultiPolygon)'
self._logger.debug(msg)
geom = self._get_geom_from_shapely()
# RasterCollection
elif isinstance(
self._geom,
(
geomesh.Raster,
geomesh.RasterCollection
)
):
msg = 'self.geom:AttributeError:(Raster, RasterCollection)'
self._logger.debug(msg)
geom = self._get_geom_from_raster()
else:
self._logger.debug('self.geom:AttributeError:Undefined')
msg = f"Undefined handler for geom type {self._geom}"
raise NotImplementedError(msg)
tmpfile = tempfile.NamedTemporaryFile(
prefix=geomesh.tmpdir, suffix='.msh')
savemsh(tmpfile.name, geom)
self.__geom_tmpfile = tmpfile
# spherical mesh
if self._radii is not None:
geom.radii = self._radii
geom.mshID = self._mshID
return geom
def jigsaw_gen_icos_grid(basename="mesh", level=4):
# setup files for JIGSAW
opts = jig.jigsaw_jig_t()
icos = jig.jigsaw_msh_t()
geom = jig.jigsaw_msh_t()
opts.geom_file = basename + '.msh'
opts.jcfg_file = basename + '.jig'
opts.mesh_file = basename + '-MESH.msh'
geom.mshID = "ellipsoid-mesh"
geom.radii = np.full(3, 1.000E+000, dtype=geom.REALS_t)
jig.savemsh(opts.geom_file, geom)
opts.hfun_hmax = +1.
opts.mesh_dims = +2 # 2-dim. simplexes
opts.optm_iter = +512
opts.optm_qtol = +1.0E-06
jig.cmd.icosahedron(opts, level, icos)
return opts.mesh_file
def setspac():
spac = jigsawpy.jigsaw_msh_t()
#------------------------------------ define spacing pattern
spac.mshID = "ellipsoid-grid"
spac.radii = np.full(3, FULL_SPHERE_RADIUS, dtype=spac.REALS_t)
spac.xgrid = np.linspace(-1. * np.pi, +1. * np.pi, 360)
spac.ygrid = np.linspace(-.5 * np.pi, +.5 * np.pi, 180)
spac.value = np.full((180, 360), +1.0E+002, dtype=spac.REALS_t)
return spac
def zipmesh(mesh, tags):
"""
ZIPMESH: "zip" a mesh down to just the verts/edges/cells
associated with the list of ID's in TAGS.
Returns a new "zipped" msh_t object.
"""
# Authors: Darren Engwirda
mout = jigsawpy.jigsaw_msh_t()
keep_cell = np.full(
mesh.tria3.size, False, dtype=np.bool)
keep_edge = np.full(
mesh.edge2.size, False, dtype=np.bool)
keep_vert = np.full(
mesh.point.size, False, dtype=np.bool)
#------------------------------------ "flag" tagged entities
for itag in tags:
keep_cell[mesh.tria3["IDtag"] == itag] = True
keep_vert[mesh.tria3[
"index"][keep_cell].flatten()] = True
keep_edge = np.logical_and.reduce((
keep_vert[mesh.edge2["index"][:, 0]],
keep_vert[mesh.edge2["index"][:, 1]])
)
mout.point = mesh.point[keep_vert]
mout.edge2 = mesh.edge2[keep_edge]
mout.tria3 = mesh.tria3[keep_cell]
#------------------------------------ update vertex indexing
redo = \
np.zeros(mesh.point.size, dtype=np.int32)
redo[keep_vert] = \
np.arange(0, np.count_nonzero(keep_vert))
mout.edge2["index"] = redo[mout.edge2["index"]]
mout.tria3["index"] = redo[mout.tria3["index"]]
return mout
def run(self, sieve=None, quality_metric=1.05):
hfun_msh_t = self.hfun.msh_t()
output_mesh = jigsaw_msh_t()
output_mesh.mshID = 'euclidean-mesh'
output_mesh.ndims = 2
self.opts.hfun_hmin = np.min(hfun_msh_t.value)
self.opts.hfun_hmax = np.max(hfun_msh_t.value)
self.opts.mesh_rad2 = float(quality_metric)
geom_msh_t = self.geom.msh_t()
# When the center of geom and hfun are NOT the same, utm
# zones would be different for resulting msh_t.
if geom_msh_t.crs != hfun_msh_t.crs:
utils.reproject(hfun_msh_t, geom_msh_t.crs)
output_mesh.crs = hfun_msh_t.crs
_logger.info('Calling libsaw.jigsaw() ...')
libsaw.jigsaw(self.opts,
geom_msh_t,
output_mesh,
init=hfun_msh_t if self._init is True else None,
hfun=hfun_msh_t)
# post process
if output_mesh.tria3['index'].shape[0] == 0:
_err = 'ERROR: Jigsaw returned empty mesh.'
_logger.error(_err)
raise Exception(_err)
if self._crs is not None:
utils.reproject(output_mesh, self._crs)
_logger.info('Finalizing mesh...')
# Don't need to use ad-hoc fix since Jigsaw tiny element
# issue is resolve. In case needed add a flag for remesh
# since it's computationally expensive
# if self.opts.hfun_hmin > 0:
# output_mesh = utils.remesh_small_elements(
# self.opts, geom_msh_t, output_mesh, hfun_msh_t)
utils.finalize_mesh(output_mesh, sieve)
_logger.info('done!')
return Mesh(output_mesh)
def coreshp(data, nset, eset, nobj, last):
"""
CORESHP: load a shape file into a jigsaw msh_t object.
"""
# Authors: Darren Engwirda
if (nlevels(data) > +1):
#---------------------------------- iterate into list lvl.
for next in data:
nobj, last = coreshp(
next, nset, eset, nobj, last)
else:
#---------------------------------- read last level coord.
npts = len(data)
temp = jigsaw_msh_t()
temp.vert2 = np.zeros(
(npts + 0), dtype=temp.VERT2_t)
temp.edge2 = np.zeros(
(npts - 1), dtype=temp.EDGE2_t)
temp.edge2["IDtag"][:] = nobj
nobj = nobj + 1
indx = np.arange(0, npts - 1) + last
last = last + npts
temp.vert2["coord"][:, 0] = \
[ipos[0] for ipos in data]
temp.vert2["coord"][:, 1] = \
[ipos[1] for ipos in data]
temp.edge2["index"][:, 0] = indx + 0
temp.edge2["index"][:, 1] = indx + 1
nset.append(temp.vert2)
eset.append(temp.edge2)
return nobj, last
def read_msh(msh_file):
mesh = jigsawpy.jigsaw_msh_t()
jigsawpy.loadmsh(msh_file, mesh)
nn = len(mesh.point)
lon_mesh = np.zeros(nn)
lat_mesh = np.zeros(nn)
for i in range(nn):
lon_mesh[i] = mesh.point[i][0][0]
lat_mesh[i] = mesh.point[i][0][1]
ne = len(mesh.tria3)
ect = np.zeros((ne, 3))
for i in range(ne):
ect[i, :] = mesh.tria3['index'][i][:]
return lon_mesh, lat_mesh
def polygeo(loop, nset, eset, nobj, last):
"""
POLYGEO: read a geoJSON poly into a jigsaw msh_t object.
"""
# Authors: Darren Engwirda
npts = len(loop) - 1
if (npts > +0):
#----------------------------------------- read LOOP dataset
temp = jigsaw_msh_t()
temp.vert2 = np.zeros(
(npts + 0), dtype=temp.VERT2_t)
temp.edge2 = np.zeros(
(npts - 0), dtype=temp.EDGE2_t)
temp.edge2["IDtag"][:] = nobj
nobj = nobj + 1
indx = np.arange(0, npts - 1) + last
itop = last + npts - 1
idx1 = np.full(
npts, itop, dtype=np.int32)
idx1[:-1] = indx + 0
idx2 = np.full(
npts, last, dtype=np.int32)
idx2[:-1] = indx + 1
last = last + npts
temp.vert2["coord"] = loop[:-1:]
temp.edge2["index"][:, 0] = idx1
temp.edge2["index"][:, 1] = idx2
nset.append(temp.vert2)
eset.append(temp.edge2)
return nobj, last
