def is_partial_edge_connected(tile_1: Tile, tile_2: Tile):
# always clockwise orientation
assert not tile_1.tile_poly.exterior.is_ccw
assert not tile_2.tile_poly.exterior.is_ccw
##########################
# checking the whether two triangle align
trinagle_1_points = list(tile_1.tile_poly.exterior.coords)
trinagle_2_points = list(tile_2.tile_poly.exterior.coords)
for i in range(tile_1.get_edge_num()):
for j in range(tile_2.get_edge_num()):
# 4 points for checking
a_1 = np.array([trinagle_1_points[i][0], trinagle_1_points[i][1]])
a_2 = np.array(
[trinagle_1_points[i + 1][0], trinagle_1_points[i + 1][1]])
line_a = a_2 - a_1
b_1 = np.array([trinagle_2_points[j][0], trinagle_2_points[j][1]])
b_2 = np.array(
[trinagle_2_points[j + 1][0], trinagle_2_points[j + 1][1]])
line_b = b_2 - b_1
# check whether the slope is the same
if abs(abs(normalize(line_a).dot(normalize(line_b))) - 1.0) < EPS \
and (abs(abs(normalize(line_a).dot(normalize(b_1 - a_2))) - 1.0) < EPS or
abs(abs(normalize(line_a).dot(normalize(b_2 - a_2))) - 1.0) < EPS):
base_vec = normalize(line_a)
unit_a_1 = 0
unit_a_2 = line_a.dot(base_vec)
unit_b_1 = (b_1 - a_1).dot(base_vec)
unit_b_2 = (b_2 - a_1).dot(base_vec)
current_overlap = max(
0.0,
min(unit_a_2, max(unit_b_1, unit_b_2)) -
max(unit_a_1, min(unit_b_1, unit_b_2)))
if current_overlap > EPS:
tile_1_edge_length = tile_1.get_edge_length(i)
tile_2_edge_length = tile_2.get_edge_length(j)
if abs(tile_1_edge_length - tile_2_edge_length) > EPS:
return True
return False
def get_all_tiles(base_tile: Tile, align_tile: Tile, integer_align):
result_tiles = []
align_tags = [] # a tag tuple to indicate the alignment types
for base_edge_idx in range(base_tile.get_edge_num()):
for align_neighbor_idx in range(align_tile.get_edge_num()):
for align_mode in [0, 1]:
align_tag = (base_tile.id, align_tile.id, base_edge_idx, align_neighbor_idx, align_mode)
if integer_align:
base_edge_length = base_tile.get_edge_length(base_edge_idx)
tile_edge_length = align_tile.get_edge_length(align_neighbor_idx)
if abs(math.floor(base_edge_length / tile_edge_length + EPS) - base_edge_length / tile_edge_length) > EPS and \
abs(math.floor(tile_edge_length / base_edge_length + EPS) - tile_edge_length / base_edge_length) > EPS:
continue
new_tile = get_tile_instance(base_tile, base_edge_idx, align_tile, align_neighbor_idx, align_mode=align_mode)
if tiling_util.intersection_area(new_tile, base_tile) < EPS:
result_tiles.append(new_tile)
align_tags.append(align_tag)
return result_tiles, align_tags