def createSynthModel():
"""Return the modeling mesh, the porosity distribution and the
parametric mesh for inversion.
"""
# Create the synthetic model
world = mt.createCircle(boundaryMarker=-1, segments=64)
tri = mt.createPolygon([[-0.8, -0], [-0.5, -0.7], [0.7, 0.5]],
isClosed=True, area=0.0015)
c1 = mt.createCircle(radius=0.2, pos=[-0.2, 0.5], segments=32,
area=0.0025, marker=3)
c2 = mt.createCircle(radius=0.2, pos=[0.32, -0.3], segments=32,
area=0.0025, marker=3)
poly = mt.mergePLC([world, tri, c1, c2])
poly.addRegionMarker([0.0, 0, 0], 1, area=0.0015)
poly.addRegionMarker([-0.9, 0, 0], 2, area=0.0015)
c = mt.createCircle(radius=0.99, segments=16, start=np.pi, end=np.pi*3)
[poly.createNode(p.pos(), -99) for p in c.nodes()]
mesh = pg.meshtools.createMesh(poly, q=34.4, smooth=[1, 10])
mesh.scale(1.0/5.0)
mesh.rotate([0., 0., 3.1415/3])
mesh.rotate([0., 0., 3.1415])
petro = pg.solver.parseArgToArray([[1, 0.9], [2, 0.6], [3, 0.3]],
mesh.cellCount(), mesh)
# Create the parametric mesh that only reflects the domain geometry
world = mt.createCircle(boundaryMarker=-1, segments=32, area=0.0051)
paraMesh = pg.meshtools.createMesh(world, q=34.0, smooth=[1, 10])
paraMesh.scale(1.0/5.0)
return mesh, paraMesh, petro
def createSynthModel():
"""Return the modelling mesh, the porosity distribution and the
parametric mesh for inversion.
"""
# Create the synthetic model
world = mt.createCircle(boundaryMarker=-1, nSegments=64)
tri = mt.createPolygon([[-0.8, -0], [-0.5, -0.7], [0.7, 0.5]],
isClosed=True, area=0.0015)
c1 = mt.createCircle(radius=0.2, pos=[-0.2, 0.5], nSegments=32,
area=0.0025, marker=3)
c2 = mt.createCircle(radius=0.2, pos=[0.32, -0.3], nSegments=32,
area=0.0025, marker=3)
poly = mt.mergePLC([world, tri, c1, c2])
poly.addRegionMarker([0.0, 0, 0], 1, area=0.0015)
poly.addRegionMarker([-0.9, 0, 0], 2, area=0.0015)
c = mt.createCircle(radius=0.99, nSegments=16, start=np.pi, end=np.pi*3)
[poly.createNode(p.pos(), -99) for p in c.nodes()]
mesh = pg.meshtools.createMesh(poly, q=34.4, smooth=[1, 10])
mesh.scale(1.0/5.0)
mesh.rotate([0., 0., 3.1415/3])
mesh.rotate([0., 0., 3.1415])
petro = pg.solver.parseArgToArray([[1, 0.9], [2, 0.6], [3, 0.3]],
mesh.cellCount(), mesh)
# Create the parametric mesh that only reflect the domain geometry
world = mt.createCircle(boundaryMarker=-1, nSegments=32, area=0.0051)
paraMesh = pg.meshtools.createMesh(world, q=34.0, smooth=[1, 10])
paraMesh.scale(1.0/5.0)
return mesh, paraMesh, petro
def test_default_create_different_center(self):
polygon = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=2,
)
assert abs(polygon.regionMarkers()[0].dist(polygon.node(0).pos()) -
0.001) < 1e-8
assert polygon.regionMarkers()[0].marker() == 2
def test_default_create_different_center(self):
polygon = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=2,
)
assert polygon.regionMarker()[0].x() == 0.5
assert polygon.regionMarker()[0].y() == -0.5
assert polygon.regionMarker()[0].marker() == 2
def test_default_create(self):
polygon = mt.createPolygon(
[[-1.0, -1.0], [-1.0, 1.0], [1.0, 1.0], [1.0, -1]],
isClosed=True,
marker=1,
)
assert polygon.regionMarker()[0].x() == 0
assert polygon.regionMarker()[0].y() == 0
assert polygon.regionMarker()[0].marker() == 1
def test_default_create_different_center(self):
polygon = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=2,
)
assert polygon.regionMarker()[0].x() == 0.5
assert polygon.regionMarker()[0].y() == -0.5
assert polygon.regionMarker()[0].marker() == 2
def test_default_create(self):
polygon = mt.createPolygon(
[[-1.0, -1.0], [-1.0, 1.0], [1.0, 1.0], [1.0, -1]],
isClosed=True,
marker=1,
)
assert polygon.regionMarker()[0].x() == 0
assert polygon.regionMarker()[0].y() == 0
assert polygon.regionMarker()[0].marker() == 1
def prepareMesh(self):
geom = mt.createPolygon(self.meshPolygonVertexes,
isClosed=True,
marker=0)
self.mesh = mt.createMesh(geom, quality=34.0, area=0.2, smooth=(1, 10))
self.startModel = np.array([1. / 2000.])[self.mesh.cellMarkers()]
print(self.mesh.cellMarkers())
print("setting of mesh")
self.travelTime.setMesh(self.mesh)
pass
def test_create_with_custom_markerPosition(self):
polygon = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=7,
markerPosition=[0.1, -0.1],
)
assert polygon.regionMarkers()[0].x() == 0.1
assert polygon.regionMarkers()[0].y() == -0.1
assert polygon.regionMarkers()[0].marker() == 7
def test_create_with_custom_markerPosition(self):
polygon = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=7,
markerPosition=[0.1, -0.1],
)
assert polygon.regionMarker()[0].x() == 0.1
assert polygon.regionMarker()[0].y() == -0.1
assert polygon.regionMarker()[0].marker() == 7
def createTopo(efile, xextra, dep):
eloc = pd.read_csv(efile, sep='\t', header=None)
nelec = eloc.values.shape[0]
topo = eloc.values[:, (1, 3)]
e_bot = np.floor(np.min(topo[:, 1]))
xL = np.floor(np.min(topo[:, 0]))
xR = np.ceil(np.max(topo[:, 0]))
L_ext = np.array([[xL - xextra, topo[0, 1]]])
R_ext = np.array([[xR + xextra, topo[nelec - 1, 1]]])
bots = np.array([[R_ext[0, 0], e_bot - dep], [L_ext[0, 0], e_bot - dep]])
combo = np.concatenate((topo, R_ext, bots, L_ext))
tpoly = mt.createPolygon(combo, isClosed=True, marker=2)
return topo, tpoly
def createFault(topo, xpos, dip, H, dep, xtra=500):
topo2 = np.concatenate(
(np.array([[topo[0, 0] - xtra, topo[0, 1]]]), topo,
np.array(
[[topo[topo.shape[0] - 1, 0] + xtra, topo[topo.shape[0] - 1,
1]]])))
e_bot = np.floor(np.min(topo2[:, 1]))
zbot = np.floor(np.min(topo2[:, 1])) - dep
Z = interpolate.interp1d(topo2[:, 0], topo2[:, 1])
zx = Z(xpos)
Dz = zx - zbot
Dx = Dz / np.tan(np.deg2rad(dip))
xbot = xpos + Dx
Dxbot = H / 2 / np.sin(np.deg2rad(dip))
LR = (xbot + Dxbot, zbot)
LL = (xbot - Dxbot, zbot)
zfR = zbot + (LR[0] - topo2[:, 0]) * np.tan(np.deg2rad(dip))
diffR = interpolate.interp1d(zfR - topo2[:, 1], topo2[:, 0])
UR = (float(diffR(0)), float(Z(diffR(0))))
zfL = zbot + (LL[0] - topo2[:, 0]) * np.tan(np.deg2rad(dip))
diffL = interpolate.interp1d(zfL - topo2[:, 1], topo2[:, 0])
UL = (float(diffL(0)), float(Z(diffL(0))))
idxabove = (topo2[topo2[:, 0] > UL[0],
0]).argmin() + (topo2[topo2[:, 0] < UL[0], 0]).shape[0]
idxbelow = (topo2[topo2[:, 0] < UR[0], 0]).argmax()
middles = [(topo[j, 0], topo[j, 1]) for j in range(idxabove, idxbelow)]
verts = [LL, UL] + middles + [UR, LR]
fpoly = mt.createPolygon(verts, isClosed=True, addNodes=3, marker=1)
return fpoly
quality=34.5 maxCellArea=1 robustData=True paraDX=0.25 lam=20 #PARAMETROS MODELADO noise=0 rhomap= [[0,100],[1,100],[2,200],[3,1000]] #CREACION MODELO GENERAL background=mt.createWorld(start=[-10,0],end=[81,-20], area=1,marker=0) pol0=mt.createPolygon([[-10,-2.5],[81,-2.5],[81,0],[-10,0]], isClosed=True,marker=1) pol1=mt.createPolygon([[-10,-15],[81,-15],[81,-2.5],[-10,-2.5]], isClosed=True,marker=2) circle1=mt.createCircle(pos=[25.5,-7.5],radius=2,isClosed=True, marker=3) circle2=mt.createCircle(pos=[45.5,-7.5],radius=2,isClosed=True, marker=3) circle3=mt.createCircle(pos=[35.5,-7.5],radius=2,isClosed=True,area=1, marker=3) world = mt.mergePLC([background,circle1,circle2,pol0,pol1]) mesh= mt.createMesh(world, quality=33, area=0.1,smooth=[1,2]) #EXPORTACION DATOS DE RESISTIVIDAD DEL MODELO (VECTOR) res_model=pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh) pg.show(mesh,res_model) #INTERPOLACION DATOS MODELO A MESH INVERSION
quality = 34.5
maxCellArea = 1
robustData = True
paraDX = 0.25
lam = 20
#PARAMETROS MODELADO
noise = 0
rhomap = [[0, 500], [1, 50], [2, 100], [3, 2000]]
#CREACION MODELO GENERAL
background = mt.createWorld(start=[-10, 0], end=[81, -20], area=1, marker=0)
pol0 = mt.createPolygon([[-10, -2.5], [27.5, -2.5], [30, 0], [-10, 0]],
isClosed=True,
marker=1)
pol1 = mt.createPolygon([[-10, -20], [10, -20], [27.5, -2.5], [-10, -2.5]],
isClosed=True,
marker=2)
pol2 = mt.createPolygon([[60, 0], [65, 0], [45, -20], [40, -20]],
isClosed=True,
marker=3)
world = mt.mergePLC([background, pol0, pol1, pol2])
mesh = mt.createMesh(world, quality=33, area=0.1, smooth=[1, 2])
#EXPORTACION DATOS DE RESISTIVIDAD DEL MODELO (VECTOR)
res_model = pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh)
end=[50, -50],
layers=[-1, -5],
worldMarker=True)
###############################################################################
# Create some heterogeneous circular anomaly
block = mt.createCircle(pos=[-5, -3.],
radius=[4, 1],
marker=4,
boundaryMarker=10,
area=0.1)
###############################################################################
poly = mt.createPolygon([(1, -4), (2, -1.5), (4, -2), (5, -2), (8, -3),
(5, -3.5), (3, -4.5)],
isClosed=True,
addNodes=3,
interpolate='spline',
marker=5)
###############################################################################
# Merge geometry definition into a Piecewise Linear Complex (PLC)
geom = world + block + poly
###############################################################################
# Optional: show the geometry
pg.show(geom)
###############################################################################
# Create a Dipole Dipole ('dd') measuring scheme with 21 electrodes.
scheme = ert.createERTData(elecs=np.linspace(start=-15, stop=15, num=21),
schemeName='dd')
lam = 50
paraDX = 0.25
#creación grid para comparación
grid = pg.createGrid(x=pg.utils.grange(start=30, end=40, n=500),
y=-pg.utils.grange(0, 4, n=250, log=False))
grid2 = pg.createGrid(x=pg.utils.grange(start=34, end=36, n=500),
y=-pg.utils.grange(0.5, 2.5, n=250, log=False))
#MODELO
rhomap = [[1, 50], [0, 200], [3, 700], [2, 75], [4, 100]]
background = mt.createWorld(start=[-10, 0], end=[81, -21], area=1, marker=1)
sup = mt.createPolygon([[-10, 0], [30, 0], [31.2, -1.5], [-10, -1.5]],
isClosed=True,
area=1,
marker=2)
sup2 = mt.createPolygon([[40, 0], [81, 0], [81, -1.5], [38.8, -1.5]],
isClosed=True,
area=1,
marker=4)
sup3 = mt.createPolygon([[30, 0], [40, 0], [39.6, -0.5], [30.4, -0.5]],
isClosed=True,
area=1,
marker=4)
pol = mt.createPolygon([[30, 0], [40, 0], [38, -2.5], [32, -2.5]],
isClosed=True,
area=1,
marker=0)
square = mt.createRectangle(start=[34, -0.5], end=[36, -2.5], area=1, marker=3)
world = mt.mergePLC([background, pol, square, sup, sup2, sup3])
def generate_dipped_layered_world(world_dim: list, layer_borders: list,
dipping_angle: float):
""" Creates a dipped layered world.
Utility function to create a dipped layered world. Region markers are increasing with depth.
Parameter:
world_dim: World dimensions as [x,z].
layer_borders: List of layer borders at world X = 0.
dipping_angle: Angle at which the layers are dipping. Value describing counter-clockwise angle.
Returns:
The created world.
"""
# Nested function to find the index to add a specific node
def get_insert_index(nodes, node):
i = 0
# Get edge starting index
while (i < len(nodes)) and (nodes[i][3] < node[3]):
i = i + 1
edge_start = i
# Get edge ending index
while (i < len(nodes)) and (nodes[i][3] <= node[3]):
i = i + 1
edge_end = i
# Check for input error
if (node[3] == 0) or (node[3] == 2) or (node[3] == 4) or (node[3]
== 6):
print('Function can only be used for non-default edges (1,3,5,7)')
return -1
# Find index based on specific edge
i = edge_start
if node[3] == 1:
while (i < edge_end) and (node[1] > nodes[i][1]):
i = i + 1
if node[3] == 3:
while (i < edge_end) and (node[2] < nodes[i][2]):
i = i + 1
if node[3] == 5:
while (i < edge_end) and (node[1] < nodes[i][1]):
i = i + 1
if node[3] == 7:
while (i < edge_end) and (node[2] > nodes[i][2]):
i = i + 1
return i
# Nested function to find the connecting node of a given node
def get_connecting_node(nodes_list, node, node_connections_list):
for i in range(len(node_connections_list)):
if node_connections_list[i][0] == nodes_list[node][0]:
for j in range(len(nodes_list)):
if node_connections_list[i][1] == nodes_list[j][0]:
return j
return -1
# Nested function to find the next node on the world border
def get_next_node(nodes_list, current_node):
if current_node >= len(nodes_list) - 1:
return 0
else:
return current_node + 1
# Nested function to create a polygon from a set of nodes
def get_polygon_from_nodes(node_set):
vertices = []
for i in range(len(node_set)):
vertices.append([node_set[i][1], node_set[i][2]])
return vertices
# Correct angle
while dipping_angle > 180:
dipping_angle -= 360
while dipping_angle < -180:
dipping_angle += 360
# Create background world
world = mt.createWorld(start=[0, 0],
end=[world_dim[0], -world_dim[1]],
worldMarker=True)
# Remove layers out of world scope
removed_indices = 0
for i in range(len(layer_borders)):
if (dipping_angle >= 0 and layer_borders[i - removed_indices] > 0) or (
dipping_angle <= 0
and layer_borders[i - removed_indices] < -world_dim[1]):
layer_borders.pop(i - removed_indices)
removed_indices = removed_indices + 1
# Compute layer height difference based on dipping angle
dipping_diff = world_dim[0] * math.tan(dipping_angle / 180 * math.pi)
# Compute nodes on world border (id,x,y,edge)
nodes = [[0, 0, 0, 0], [1, world_dim[0], 0, 2],
[2, world_dim[0], -world_dim[1], 4], [3, 0, -world_dim[1], 6]]
node_connections = []
next_id = 4
for i in range(len(layer_borders)):
# Find starting node
if layer_borders[i] <= 0 and layer_borders[i] >= -world_dim[1]:
# Layer starts at left world border (default case)
start_node = [next_id, 0, layer_borders[i], 7]
else:
if layer_borders[i] > 0:
# Layer starts above world
x = layer_borders[i] * math.tan(
(90 + dipping_angle) * math.pi / 180)
start_node = [next_id, x, 0, 1]
else:
# Layer starts below world
x = -(layer_borders[i] + world_dim[1]) * math.tan(
(90 - dipping_angle) * math.pi / 180)
start_node = [next_id, x, -world_dim[1], 5]
nodes.insert(get_insert_index(nodes, start_node), start_node)
next_id = next_id + 1
# Find ending node
if layer_borders[i] + dipping_diff <= 0 and layer_borders[
i] + dipping_diff >= -world_dim[1]:
# Layer ends at right world border (default case)
end_node = [
next_id, world_dim[0], layer_borders[i] + dipping_diff, 3
]
else:
if layer_borders[i] + dipping_diff > 0:
# Layer ends above world
x = -layer_borders[i] / math.tan(dipping_angle / 180 * math.pi)
end_node = [next_id, x, 0, 1]
else:
# Layer ends below world
x = world_dim[0] - (layer_borders[i] + dipping_diff +
world_dim[1]) / math.tan(
dipping_angle / 180 * math.pi)
end_node = [next_id, x, -world_dim[1], 5]
nodes.insert(get_insert_index(nodes, end_node), end_node)
next_id = next_id + 1
# Save node connections
node_connections.append([start_node[0], end_node[0]])
node_connections.append([end_node[0], start_node[0]])
# Compute polygons from nodes
polygons = []
first_node = 0
edge_to_finish = 4
if dipping_angle < 0:
for i in range(len(nodes)):
if nodes[i][3] == 2:
break
first_node = i
edge_to_finish = 6
while edge_to_finish != -1:
polygon = []
last_node_was_connected = False
has_connected_nodes = False
current_node_index = first_node
polygon.append(nodes[first_node])
while (len(polygon) == 1) or (polygon[len(polygon) - 1] != polygon[0]):
if (last_node_was_connected
== False) and (len(polygon) != 1) and (get_connecting_node(
nodes, current_node_index, node_connections) != -1):
current_node_index = get_connecting_node(
nodes, current_node_index, node_connections)
polygon.append(nodes[current_node_index])
last_node_was_connected = True
has_connected_nodes = True
if nodes[current_node_index][3] == edge_to_finish:
edge_to_finish = -1
continue
current_node_index = get_next_node(nodes, current_node_index)
polygon.append(nodes[current_node_index])
if not has_connected_nodes:
first_node = current_node_index
last_node_was_connected = False
if nodes[current_node_index][3] == edge_to_finish:
edge_to_finish = -1
polygons.append(polygon[:-1])
# Merge geometries
for i in range(len(polygons)):
poly = mt.createPolygon(get_polygon_from_nodes(polygons[i]),
marker=i + 1,
isClosed=True)
world = mt.mergePLC([world, poly])
return world
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
print('Position marker number {}:'.format(nr + 1), marker.x(), marker.y(),
marker.z())
ax.scatter(marker.x(), marker.y(), s=(2 - nr) * 30, color='k')
ax.set_title('marker positions - working example')
fig.show()
###############################################################################
# The same issue can occur for polygons. Polygons can assume complex forms, but
# for simplicity we create cubes here.
polygon1 = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=1,
)
polygon2 = mt.createPolygon(
[[0.25, -0.25], [0.75, -0.25], [0.75, -0.75], [0.25, -0.75]],
isClosed=True,
marker=2,
)
plc = mt.mergePLC([polygon1, polygon2])
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
Refraction Manager
------------------
This example shows how to use the Refraction manager to generate the response
of a three-layered sloping model and to invert the synthetic noisified data."""
import numpy as np
import pygimli as pg
import pygimli.meshtools as mt
from pygimli.physics import Refraction
###############################################################################
# We start by creating a three-layered slope (The model is taken from the BSc
# thesis of Constanze Reinken (University of Bonn).
layer1 = mt.createPolygon([[0.0, 137], [117.5, 164], [117.5, 162], [0.0, 135]],
isClosed=True, marker=1, area=1)
layer2 = mt.createPolygon([[0.0, 126], [0.0, 135], [117.5, 162], [117.5, 153]],
isClosed=True, marker=2)
layer3 = mt.createPolygon([[0.0, 110], [0.0, 126], [117.5, 153], [117.5, 110]],
isClosed=True, marker=3)
slope = (164 - 137) / 117.5
geom = mt.mergePLC([layer1, layer2, layer3])
mesh = mt.createMesh(geom, quality=34.3, area=3, smooth=[1, 10])
pg.show(mesh)
###############################################################################
# Next we define geophone positions and a measurement scheme, which consists of
# shot and receiver indices.
end=[50, -50],
layers=[-1, -5],
worldMarker=True)
###############################################################################
# Create some heterogeneous circular anomaly
block = mt.createCircle(pos=[-5, -3.],
radius=[4, 1],
marker=4,
boundaryMarker=10,
area=0.1)
###############################################################################
poly = mt.createPolygon([(1, -4), (2, -1.5), (4, -2), (5, -2), (8, -3),
(5, -3.5), (3, -4.5)],
isClosed=True,
addNodes=5,
marker=5)
###############################################################################
# Merge geometry definition into a Piecewise Linear Complex (PLC)
geom = world + block + poly
###############################################################################
# Optional: show the geometry
pg.show(geom)
###############################################################################
# Create a Dipole Dipole ('dd') measuring scheme with 21 electrodes.
scheme = ert.createERTData(elecs=np.linspace(start=-15, stop=15, num=21),
schemeName='dd')
------------------
This example shows how to use the Refraction manager to generate the response
of a three-layered sloping model and to invert the synthetic noisified data."""
import numpy as np
import pygimli as pg
import pygimli.meshtools as mt
from pygimli.physics import Refraction
###############################################################################
# We start by creating a three-layered slope (The model is taken from the BSc
# thesis of Constanze Reinken (University of Bonn).
layer1 = mt.createPolygon([[0.0, 137], [117.5, 164], [117.5, 162], [0.0, 135]],
isClosed=True,
marker=1,
area=1)
layer2 = mt.createPolygon([[0.0, 126], [0.0, 135], [117.5, 162], [117.5, 153]],
isClosed=True,
marker=2)
layer3 = mt.createPolygon([[0.0, 110], [0.0, 126], [117.5, 153], [117.5, 110]],
isClosed=True,
marker=3)
slope = (164 - 137) / 117.5
geom = mt.mergePLC([layer1, layer2, layer3])
mesh = mt.createMesh(geom, quality=34.3, area=3, smooth=[1, 10])
pg.show(mesh)
###############################################################################
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
print('Position marker number {}:'.format(nr + 1), marker.x(), marker.y(),
marker.z())
ax.scatter(marker.x(), marker.y(), s=(2 - nr) * 30, color='k')
ax.set_title('marker positions - working example')
fig.show()
###############################################################################
# The same issue can occur for polygons. Polygons can assume complex forms, but
# for simplicity we create cubes here.
polygon1 = mt.createPolygon(
[[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]],
isClosed=True,
marker=1,
)
polygon2 = mt.createPolygon(
[[0.25, -0.25], [0.75, -0.25], [0.75, -0.75], [0.25, -0.75]],
isClosed=True,
marker=2,
)
plc = mt.mergePLC([polygon1, polygon2])
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
