def extend_tile(p1, p2, currentcase, oldcase, tile):
# Copy of visualize
visitedcases = [currentcase % len(tile)]
tilepoints = list()
to_visit = [(p1, p2, currentcase, oldcase)]
while to_visit:
p1, p2, currentcase, oldcase = to_visit.pop()
realcurrent = currentcase % len(tile)
# visitedcases.append(realcurrent) #too late! if two cases go to the same case that doesn't get explored until after
points = get_face_points(p1, p2, len(tile[realcurrent]))
if DEBUG1: Draw.polygon_shape(points, (255, 0, 0), alpha=0.1, outline=1)
if DEBUG4: print("Extend", currentcase)
if DEBUG4: print(visitedcases)
if DEBUG1: Draw.text_center(str(realcurrent), *centerpoint(points), (0, 0, 0), 12)
if DEBUG1: Draw.refresh()
# sleep(0.01)
tilepoints.append(points)
currentborder = tile[realcurrent] # print(currentborder, 'of shape', realcurrent, ', coming from', oldcase)
base, match = find_matching(oldcase, currentcase, tile)
# if(DEBUG1):print(match)
shift = currentborder.index(match) # index = current.index(-oldcase + 2 * (oldcase % len(order)))
# if(DEBUG1):print("Aligned on %d index %d"%(oldcase,shift))
# print(index)
currentborder = currentborder[shift:] + currentborder[:shift + 1]
for index, nextcase in enumerate(currentborder):
p1 = points[index % len(points)]
p2 = points[(index + 1) % len(points)]
if (nextcase not in visitedcases) and (nextcase % len(tile) == nextcase):
to_visit.append([p2, p1, nextcase, currentcase])
visitedcases.append(nextcase)
# if(DEBUG1):print("De %d, index %d next %d"%(realcurrent, index,nextcase))
if DEBUG1: Draw.wait_for_input()
return tilepoints
def get_neighbours_positions(tile, p1=P1, p2=P2, startcase=0, recurse=0):
neighbours_coords = dict()
if recurse:
neighbours_neighbours = dict()
if DEBUG4:
nn_debug = dict()
explored = list()
####PART 1 : explore and list all neighbouring tiles
to_explore = [list((p1, p2, startcase))]
while to_explore:
initial_p1, initial_p2, case = to_explore.pop() # the initial shape from which the exploration starts
if recurse:
c = centeroftilestarting(initial_p1, initial_p2, tile[case % len(tile)][0], case, tile, 1)
if DEBUG4:
print("Center received", c)
Draw.text_center("_0_", *c, (128, 0, 0), 30)
initial_points = get_face_points(initial_p1, initial_p2, len(tile[case]))
if DEBUG1: Draw.polygon_shape(initial_points, (0, 255 * recurse, 0), alpha=.5, outline=1)
initial_points = initial_points + initial_points
if DEBUG1: Draw.text_center(str(case), *centerpoint(initial_points), (0, 0, 255), 12)
if DEBUG1: Draw.refresh()
explored.append(case)
if DEBUG1: Draw.wait_for_input()
for index, next in enumerate(tile[case]):
branch_p1 = initial_points[index]
branch_p2 = initial_points[index + 1]
branch_points = 2 * get_face_points(branch_p2, branch_p1, len(
tile[next % len(tile)])) # the direction of the segment has to be reversed
# branch_points triangle starts at [case] as its origin
# but next triangle loop considers starts at 0 (forgets previous)
# rotate the triangle so that the origin side is 0
if next % len(tile) == next and next != case:
side_offset = len(tile[next]) - tile[next].index(case)
next_p1, next_p2 = branch_points[side_offset:side_offset + 2]
# inside the net (excluding self-ref which are outside)
if next not in explored:
# Branch out inside
to_explore.append([next_p1, next_p2, next])
else:
# outside the net= neighbour data
branch_p1 = initial_points[index]
branch_p2 = initial_points[index + 1]
# branch_points = 2*get_face_points(branch_p2, branch_p1, len(tile[case])) #the direction of the segment has to be reversed
# side_offset = len(tile[next%len(tile)])-index#len(tile[next%len(tile)])-find_matching_offset(case,next,tile)
# next_p1, next_p2 = branch_points[side_offset:side_offset+2]
if DEBUG1: print("Going outside: %d to %d index %d" % (case, next % len(tile), index))
neighbour = centeroftilestarting(branch_p2, branch_p1, case, next,
tile) # this takes prev tile so no shift
neighbours_coords.setdefault(neighbour, [])
neighbours_coords[neighbour].append((case, next))
if recurse:
# current, sym = find_matching(case,next,tile)
side_offset = len(tile[next % len(tile)]) - find_matching_offset(case, next, tile)
next_p1, next_p2 = branch_points[side_offset:side_offset + 2]
nn = get_neighbours_positions(tile, next_p1, next_p2, next % len(tile), recurse=False)
for n in nn:
nn[n].sort()
if DEBUG4:
debug_data = (next_p1, next_p2, next % len(tile))
if neighbour in neighbours_neighbours:
if neighbours_neighbours[neighbour] != nn:
print("Not matching when reading neighbour", neighbour,
"'s neighbours from two different sides:\nOriginal:")
print(nn_debug[neighbour])
pp.pprint(neighbours_neighbours[neighbour])
print("New: (coming from %d to %d)" % (case, next))
print(debug_data)
pp.pprint(nn)
nn_debug.setdefault(neighbour, debug_data)
neighbours_neighbours.setdefault(neighbour, nn)
# continue
# print("exploring",p1,p2,"case",case,"face",face,orientation,tilecoord, tilecoordsign )
if len(tile[case % len(tile)]) != len(poly[face]):
continue
# caseorientation = 0
# orientation is tileorientation
# print("Known positions for",case%len(tile),face,orientation)
# print(positions[(case%len(tile),face,orientation)])
if tilecoord in positions[(case % len(tile), face, orientation)]:
continue
# if(not is_known((case,face,orientation),tilecoord,positions,symmetry_axis)):
startpoints = get_face_points(p1, p2, len(poly[face]))
color = Draw.colors[sum([abs(x * (n + 1)) for n, x in enumerate(tilecoord)]) % len(Draw.colors)]
Draw.polygon_shape(startpoints, color, 0.75, 1)
# Draw.text_center("%d/%d+%d"%(face,case%len(tile),(case-(case%len(tile)))//len(tile)),*centerpoint(startpoints),(255,255,255),int(ext/2))
Draw.text_center(str(tilecoord) + str(tilecoordsign), *centerpoint(startpoints), (255, 255, 255), int(ext / 4))
# Draw.text_center("%d(%d)"%(case,(case-(case%len(tile)))//len(tile)),*centerpoint(startpoints),(255,255,255),int(ext/2))
Draw.refresh()
# Draw.wait_for_input()
if len(positions[(case % len(tile), face, orientation)]) == 0:
# add_new_symmetry((case,face,orientation),tilecoord,positions,symmetry_axis)
# Draw.wait_for_input()
newcases = tile[case % len(tile)]
newfaces = poly[face][orientation:] + poly[face][:orientation]
if DEBUG3: print(case % len(tile), newcases)
if DEBUG3: print(face % len(poly), newfaces)
for i in range(len(newcases)):
newface = newfaces[i]
newcase = newcases[i]
# if(newcase%len(tile)!=newcase):
# continue
def number(id, point):
# graph.create_text((point.x, point.y), text=str(id))
Draw.text_center(str(id), point.x, point.y, (0, 0, 0), textsize)