def test_split_wires(self):
decomp = PolygonDecomposition()
# square
sg_a, = decomp.add_line((0, 0), (2, 0))
sg_b, = decomp.add_line((2, 0), (2, 2))
sg_c, = decomp.add_line((2, 2), (0, 2))
sg_d, = decomp.add_line((0, 2), (0, 0))
def test_join_segments(self):
pd = PolygonDecomposition()
decomp = pd.decomp
sg0, = pd.add_line((0, 0), (1, 0))
mid_pt = sg0.vtxs[1]
sg1, = pd.add_line((2, 0), (1, 0))
sg2, = pd.add_line((2, 0), (3, 0))
decomp.join_segments(sg0.vtxs[1], sg0, sg1)
decomp.join_segments(sg0.vtxs[1], sg0, sg2)
def test_join_wires(self):
decomp = PolygonDecomposition()
sg, = decomp.add_line((0, 0), (0, 2))
pt0 = sg.vtxs[0]
decomp.add_line((0, 0), (2, 0))
decomp.add_line((0, 2), (2, 0))
sg4, = decomp.add_line((.5, .5), (0.6, 0.6))
decomp.new_segment(sg4.vtxs[0], pt0)
assert len(decomp.decomp.wires) == 3
decomp = PolygonDecomposition()
def test_contains(self):
decomp = PolygonDecomposition()
sg_a, = decomp.add_line((0, 0), (2, 0))
sg_b, = decomp.add_line((2, 0), (2, 2))
sg_c, = decomp.add_line((2, 2), (0, 2))
sg_d, = decomp.add_line((0, 2), (0, 0))
in_wire = sg_a.wire[left_side]
assert in_wire.contains_point([-1, 1]) == False
assert in_wire.contains_point([-0.0001, 1]) == False
assert in_wire.contains_point([+0.0001, 1]) == True
assert in_wire.contains_point([1.999, 1]) == True
assert in_wire.contains_point([2.0001, 1]) == False
def test_join_poly(self):
pd = PolygonDecomposition()
decomp = pd.decomp
sg0, = pd.add_line((0, 0), (0, 2))
pd.add_line((0, 0), (2, 0))
sg2, = pd.add_line((0, 2), (2, 0))
pd.delete_segment(sg2)
def test_frac_intersections():
# import sys
# import trace
#
# # create a Trace object, telling it what to ignore, and whether to
# # do tracing or line-counting or both.
# tracer = trace.Trace(
# ignoredirs=[sys.prefix, sys.exec_prefix],
# trace=0,
# count=1)
da = PolygonDecomposition()
box = np.array([[0.0, 0.0], [2.0, 3.0]])
p00, p11 = box
p01 = np.array([p00[0], p11[1]])
p10 = np.array([p11[0], p00[1]])
da.add_line(p00, p01)
da.add_line(p01, p11)
da.add_line(p11, p10)
da.add_line(p10, p00)
decomps = [da]
np.random.seed(1)
n_frac = 50
p0 = np.random.rand(n_frac, 2) * (box[1] - box[0]) + box[0]
p1 = np.random.rand(n_frac, 2) * (box[1] - box[0]) + box[0]
for pa, pb in zip(p0, p1):
dd = PolygonDecomposition()
dd.add_line(pa, pb)
decomps.append(dd)
def tracer_func():
return merge.intersect_decompositions(decomps)
# import cProfile
# cProfile.runctx('tracer_func()', globals(), locals(), 'prof_stats')
#
# import pstats
# p = pstats.Stats('prof_stats')
# p.sort_stats('cumulative').print_stats()
decomp, maps = tracer_func()
#######
# Test merge with empty decomp.
# Test fix for split points under tolerance.
copy_decomp, maps = merge.intersect_decompositions([decomp])
def test_add_dendrite(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pt0 = pd.add_point((31.6, -40))
pt1 = pd.add_point((32.4, -62.8))
pt2 = pd.add_point((57.7, -37.4))
pd.new_segment(pt0, pt1)
pd.new_segment(pt0, pt2)
pd.new_segment(pt1, pt2)
def test_main_polygon_with_childs(self):
da = PolygonDecomposition()
decomp = da.decomp
seg_in, = da.add_line((0.1, 0.5), (0.9, 0.5))
seg_out, = da.add_line((0.1, -0.5), (0.9, -0.5))
da.add_line((0, 0), (1, 0))
da.add_line((0, 0), (0, 1))
da.add_line((1, 1), (1, 0))
da.add_line((1, 1), (0, 1))
assert seg_in.wire[0] == seg_in.wire[1]
assert seg_in.wire[0].polygon != decomp.outer_polygon
assert seg_out.wire[0] == seg_out.wire[1]
assert seg_out.wire[0].polygon == decomp.outer_polygon
def test_join_polygons_embedded(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pd.add_line((0, 0), (3, 0))
pd.add_line((0, 0), (0, 3))
sg3, = pd.add_line((0, 3), (3, 0))
pd.delete_segment(sg3)
assert len(decomp.outer_polygon.outer_wire.childs) == 1
wire = list(decomp.outer_polygon.outer_wire.childs)[0]
assert len(wire.childs) == 0
def test_polygon_depth(self):
pd = PolygonDecomposition()
decomp = pd.decomp
# outer square
sg_a, = pd.add_line((0, 0), (2, 0))
sg_b, = pd.add_line((2, 0), (2, 2))
sg_c, = pd.add_line((2, 2), (0, 2))
sg_d, = pd.add_line((0, 2), (0, 0))
# inner square
sg_e, = pd.add_line((0.5, 0.5), (1, 0.5))
sg_f, = pd.add_line((1, 0.5), (1, 1))
sg_g, = pd.add_line((1, 1), (0.5, 1))
sg_h, = pd.add_line((0.5, 1), (0.5, 0.5))
assert decomp.polygons[0].depth() == 0
assert decomp.polygons[1].depth() == 2
assert decomp.polygons[2].depth() == 4
def test_polygon_childs(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pd.add_line((0, 0), (4, 0))
pd.add_line((0, 0), (0, 4))
pd.add_line((0, 4), (4, 0))
pd.add_line((1, 1), (2, 1))
pd.add_line((1, 1), (1, 2))
pd.add_line((1, 2), (2, 1))
#plot_polygon_decomposition(decomp)
lst = list(pd.get_childs(0))
assert lst == [0, 1, 2]
pd.add_line((1, 1), (0, 0))
pd.add_line((2, 1), (4, 0))
pd.add_line((1, 2), (0, 4))
def test_polygon_childs_degenerate(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pd.add_line((0, 0), (3, 0))
pd.add_line((0, 0), (0, 3))
pd.add_line((0, 3), (3, 0))
pd.add_line((1, 1), (2, 1))
pd.add_line((1, 1), (1, 2))
pd.add_line((1, 2), (2, 1))
#plot_polygon_decomposition(decomp)
pd.add_line((1, 1), (0, 0))
pd.add_line((2, 1), (3, 0))
pd.add_line((1, 2), (0, 3))
def test_complex_join_polygons(self):
da = PolygonDecomposition()
# outer triangle
da.add_line((0, 4), (0, 0))
da.add_line((0, 0), (4, 0))
da.add_line((4, 0), (0, 4))
# inner triangle
da.add_line((1, 2), (1, 1))
da.add_line((1, 1), (2, 1))
seg, = da.add_line((2, 1), (1, 2))
# inner triangle
da.add_line((1.2, 1.6), (1.2, 1.2))
da.add_line((1.2, 1.2), (1.6, 1.2))
da.add_line((1.6, 1.2), (1.2, 1.6))
da.decomp.check_consistency()
#plot_polygon_decomposition(da)
da.delete_segment(seg)
da.decomp.check_consistency()
def test_split_poly(self):
pd = PolygonDecomposition()
decomp = pd.decomp
sg_a, = pd.add_line((0, 0), (2, 0))
sg_b, = pd.add_line((2, 0), (2, 2))
sg_c, = pd.add_line((2, 2), (0, 2))
sg_d, = pd.add_line((0, 2), (0, 0))
# closed outer polygon
assert sg_a.next == [(sg_d, 0), (sg_b, 1)]
assert sg_b.next == [(sg_a, 0), (sg_c, 1)]
assert sg_c.next == [(sg_b, 0), (sg_d, 1)]
assert sg_d.next == [(sg_c, 0), (sg_a, 1)]
external_wire = list(decomp.outer_polygon.outer_wire.childs)[0]
assert sg_a.wire[right_side] == external_wire
assert sg_b.wire[right_side] == external_wire
assert sg_c.wire[right_side] == external_wire
assert sg_d.wire[right_side] == external_wire
#plot_polygon_decomposition(decomp)
assert len(decomp.polygons) == 2
sg_e, = pd.add_line((0.5, 0.5), (1, 0.5))
sg_f, = pd.add_line((1, 0.5), (1, 1))
sg_g, = pd.add_line((1, 1), (0.5, 1))
sg_h, = pd.add_line((0.5, 1), (0.5, 0.5))
# closed inner polygon
#plot_polygon_decomposition(decomp)
print("Decomp:\n", pd)
out_square = sg_a, sg_b, sg_c, sg_d
in_square = sg_e, sg_f, sg_g, sg_h
self.check_split_poly_structure(decomp, out_square, in_square)
# join nested wires
sg_x = pd.new_segment(sg_e.vtxs[out_vtx], sg_a.vtxs[out_vtx])
# split nested wires
#plot_polygon_decomposition(decomp)
pd.delete_segment(sg_x)
self.check_split_poly_structure(decomp, out_square, in_square)
# Join nested wires, oposite (other order of wires in _split_wires)
sg_x = pd.new_segment(sg_a.vtxs[out_vtx], sg_e.vtxs[out_vtx])
# split nested wires
#plot_polygon_decomposition(decomp)
pd.delete_segment(sg_x)
self.check_split_poly_structure(decomp, out_square, in_square)
# split polygon - balanced
seg_y, = pd.add_line((0.5, 0.5), (1, 1))
# join polygons - balanced
pd.delete_segment(seg_y)
self.check_split_poly_structure(decomp, out_square, in_square)
# join nested polygons
pd.delete_segment(sg_h)
#plot_polygon_decomposition(decomp)
assert sg_b.wire == sg_a.wire
assert sg_c.wire == sg_a.wire
assert sg_d.wire == sg_a.wire
assert sg_f.wire == sg_e.wire
assert sg_g.wire == sg_e.wire
assert sg_h.wire == sg_e.wire
we_r, we_l = sg_e.wire
assert we_r == we_l
wire1 = decomp.outer_polygon.outer_wire
wire2 = list(wire1.childs)[0]
wire3 = list(wire2.childs)[0]
assert sg_a.wire == [wire2, wire3]
wire4 = list(wire3.childs)[0]
assert we_r == wire4
assert len(wire4.childs) == 0
def test_decomp(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pd.set_tolerance(0.01)
outer = decomp.outer_polygon
assert pd.get_last_polygon_changes() == (PolygonChange.add, outer.id,
outer.id)
# test add point
pt_a = pd.add_point([0, 0])
assert pt_a.poly == outer
pt_b = pd.add_point([1, 0])
assert pt_a.poly == outer
# test snap to point
pt = pd._snap_point([0, 5e-3])
assert pt == (0, pt_a, None)
pt = pd._snap_point([5e-3, 5e-3])
assert pt == (0, pt_a, None)
pt = pd._snap_point([1 + 5e-3, 5e-3])
assert pt == (0, pt_b, None)
# test new_segment, new_wire
sg_c = pd.new_segment(pt_a, pt_b)
assert len(decomp.polygons) == 1
assert len(decomp.outer_polygon.outer_wire.childs) == 1
assert pd.get_last_polygon_changes() == (PolygonChange.none, None,
None)
# test line matching existing segment
sg_c = pd.new_segment(pt_a, pt_b)
sg_c = pd.new_segment(pt_b, pt_a)
# test add_line - new_segment, add_dendrite
res = pd.add_line((0, 0), (0, 1))
assert len(res) == 1
sg_d = res[0]
assert sg_d.next[left_side] == (sg_d, right_side)
assert sg_d.next[right_side] == (sg_c, left_side)
assert sg_c.next[left_side] == (sg_c, right_side)
assert sg_c.next[right_side] == (sg_d, left_side)
assert pt_a.poly == None
assert pt_a.segment == (sg_c, out_vtx)
assert pd.get_last_polygon_changes() == (PolygonChange.shape,
[outer.id], None)
res = pd.add_line((2, 0), (3, 1))
sg_x, = res
assert len(decomp.polygons) == 1
assert len(decomp.outer_polygon.outer_wire.childs) == 2
# test snap point - snap to line
pt = pd._snap_point([0.5, 5e-3])
assert pt == (1, sg_c, 0.5)
pt = pd._snap_point([5e-3, 0.3])
assert pt == (1, sg_d, 0.3)
pt = pd._snap_point([1 + 5e-3, 5e-3])
assert pt == (0, pt_b, None)
print(pd)
# test _split_segment, new segment - add_dendrite
result = pd.add_line((2, 1), (3, 0))
sg_e, sg_f = result
assert pd.get_last_polygon_changes() == (PolygonChange.shape,
[outer.id], None)
assert sg_e.next[right_side] == (sg_e, left_side)
sg_h = sg_e.next[left_side][0]
assert sg_e.next[left_side] == (sg_h, left_side)
assert sg_h.next[left_side] == (sg_h, right_side)
assert sg_h.next[right_side] == (sg_f, left_side)
assert sg_f.next[left_side] == (sg_f, right_side)
sg_g = sg_f.next[right_side][0]
assert sg_f.next[right_side] == (sg_g, right_side)
assert sg_g.next[right_side] == (sg_g, left_side)
assert sg_g.next[left_side] == (sg_e, right_side)
sg_o, sg_p = pd.add_line((2.5, 0), (3, 0.5))
# test add_point on segment
pd.add_point((2.25, 0.75))
# test new_segment - split polygon
pd.add_line((-0.5, 1), (0.5, 0))
assert pd.get_last_polygon_changes() == (PolygonChange.add, outer.id,
1)
#plot_polygon_decomposition(decomp)
# test split_segment in vertex
pd.add_line((2, 0.5), (2, -0.5))
# test new_segment - join_wires
assert len(decomp.wires) == 4
assert len(decomp.polygons) == 2
print(decomp)
#plot_polygon_decomposition(decomp)
sg_m, = pd.add_line((0, 1), (2, 1))
print(decomp)
assert len(decomp.wires) == 3
assert len(decomp.polygons) == 2
assert pd.get_last_polygon_changes() == (PolygonChange.shape,
[outer.id], None)
#plot_polygon_decomposition(decomp)
# delete segment - split wire
pd.delete_segment(sg_m)
decomp.check_consistency()
assert len(decomp.wires) == 4
assert len(decomp.polygons) == 2
#plot_polygon_decomposition(decomp)
assert pd.get_last_polygon_changes() == (PolygonChange.shape,
[outer.id], None)
# other split wire
pt_op = sg_p.vtxs[out_vtx]
pd.delete_segment(sg_f)
decomp.check_consistency()
assert len(decomp.wires) == 5
assert len(decomp.polygons) == 2
#plot_polygon_decomposition(decomp)
#test split_segment connected on both sides; split non outer polygon
seg_y, = pd.add_line((0, 0.25), (0.25, 0.25))
decomp.check_consistency()
assert pd.get_last_polygon_changes() == (PolygonChange.split, 1, 2)
# test _join_segments - _split_segment inversion
seg1 = sg_e
mid_point = seg1.vtxs[in_vtx]
seg0 = sg_e.next[left_side][0]
mid_pt = decomp.join_segments(mid_point, seg0, seg1)
decomp.remove_free_point(mid_pt)
decomp.check_consistency()
# print("Decomp:\n", decomp)
pd.delete_point(pt_op)
# plot_polygon_decomposition(decomp)
# test join polygons
pd.delete_segment(seg_y)
assert pd.get_last_polygon_changes() == (PolygonChange.join, 1, 2)
def test_complex_wire_remove(self):
da = PolygonDecomposition()
# outer triangle
da.add_line((0, 4), (0, 0))
da.add_line((0, 0), (4, 0))
da.add_line((4, 0), (0, 4))
# inner triangle
da.add_line((1, 2), (1, 1))
da.add_line((1, 1), (2, 1))
da.add_line((2, 1), (1, 2))
# rugs
sa, = da.add_line((2, 1), (4, 0))
sb, = da.add_line((1, 2), (0, 4))
#print("initial dc:\n", da)
#plot_polygon_decomposition(da)
da.delete_segment(sb)
da.delete_segment(sa)
def test_seg_add_remove(self):
pd = PolygonDecomposition()
decomp = pd.decomp
pd.add_line((0, 1), (0, 0))
pd.add_line((0, 0), (1, 0))
seg_c, = pd.add_line((1, 0), (0, 1))
pd.add_line((1, 0), (2, 0))
pd.add_line((2, 0), (2, 1))
pd.add_line((1, 0), (2, 1))
#plot_polygon_decomposition(decomp)
assert len(decomp.outer_polygon.outer_wire.childs) == 1
assert len(decomp.outer_polygon.outer_wire.childs.pop().childs) == 2
pd.delete_segment(seg_c)
def test_split_triangle(self):
decomp = PolygonDecomposition()
pt1 = decomp._add_point([0, 0], decomp.outer_polygon)
pt2 = decomp._add_point([2, 0], decomp.outer_polygon)
pt3 = decomp._add_point([1, 1], decomp.outer_polygon)
mid_pt = decomp._add_point([1, 0], decomp.outer_polygon)
seg = decomp._add_segment(pt1, pt2)
decomp._add_segment(pt2, pt3)
decomp._add_segment(pt3, pt1)
new_seg = decomp._split_segment(seg, mid_pt)
decomp._join_segments(mid_pt, seg, new_seg)
def test_split_poly_1(self):
# Test splitting of points and holes.
pd = PolygonDecomposition()
decomp = pd.decomp
pd.add_line((0, 0), (1, 0))
pd.add_line((0, 0), (0, 1))
pd.add_line((1, 1), (1, 0))
pd.add_line((1, 1), (0, 1))
pd.add_point((0.2, 0.2))
pd.add_point((0.8, 0.2))
pd.add_line((0.2, 0.6), (0.3, 0.6))
pd.add_line((0.8, 0.6), (0.7, 0.6))
#plot_polygon_decomposition(decomp)
pd.add_line((0.5, 0), (0.5, 1))
def test_simple():
# layer geometry object
lg = LayerGeometry()
# create interfaces
top_iface = lg.add_interface(transform_z=(1.0, 0.0), elevation=0.0)
bot_iface = lg.add_interface(transform_z=(1.0, 0.0), elevation=-1.0)
# add region to layer geometry
reg = lg.add_region(name="region_name", dim=RegionDim.bulk)
# create decomposition
decomp = PolygonDecomposition()
pt1 = decomp.add_point((0.0, 0.0))
pt2 = decomp.add_point((10.0, 0.0))
pt3 = decomp.add_point((10.0, 10.0))
pt4 = decomp.add_point((0.0, 10.0))
decomp.add_line_for_points(pt1, pt2)
decomp.add_line_for_points(pt2, pt3)
decomp.add_line_for_points(pt3, pt4)
decomp.add_line_for_points(pt4, pt1)
res = decomp.get_last_polygon_changes()
#assert res[0] == PolygonChange.add
polygon = decomp.polygons[res[2]]
decomp.set_attr(polygon, reg)
# add layer to layer geometry
lg.add_stratum_layer(decomp, top_iface, decomp, bot_iface)
# generate mesh file
lg.filename_base = sandbox_fname("mesh_simple", "")
lg.init()
lg.construct_brep_geometry()
lg.make_gmsh_shape_dict()
lg.distribute_mesh_step()
lg.call_gmsh(mesh_step=0.0)
lg.modify_mesh()
def test_simple_intersections():
da = PolygonDecomposition()
da.add_line((0, 0), (1, 0))
da.add_line((0, 0), (0, 1))
da.add_line((1, 1), (1, 0))
da.add_line((1, 1), (0, 1))
da.add_line((0, 0), (1, 1))
#print("da:\n", da)
db = PolygonDecomposition()
db.add_line((0, 0), (1, 0))
db.add_line((0, 0), (0, 1))
db.add_line((1, 1), (1, 0))
db.add_line((1, 1), (0, 1))
db.add_line((1, 0), (0, 1))
#print("db:\n", db)
(dc, maps_a, maps_b) = merge.intersect_single(da, db)
#print("dc\n", dc)
#plot_polygon_decomposition(dc)
assert maps_a[0] == {}
assert maps_b[0] == {0: 0, 1: 1, 2: 2, 3: 3}
assert maps_a[1] == {5: 4}
assert maps_b[1] == {0: 0, 1: 1, 2: 2, 3: 3, 6: 4, 7: 4}
assert maps_a[2] == {3: 1, 4: 2}
assert maps_b[2] == {0: 0, 1: 1, 2: 1, 3: 2, 4: 2}
