def build_query_graph():
global dependency_tree
dependency_tree = nlp.dependency_parse(question)
convert_tree()
edges = []
# 2-2 find path
if len(nodes) == 1:
n = nodes[0]
pre_attribute = ' '.join(tokens[:n.index - 1])
edges.append(Edge(pre_attribute, Node('', 'wh', []), n))
return edges
for n in nodes:
node_indexes.append(n.index)
for i in range(len(node_indexes) - 1):
n1 = node_indexes[i]
for j in range(i + 1, len(node_indexes)):
n2 = node_indexes[j]
path = find_path(tree_node_dic[n1], tree_node_dic[n2])
if path:
word = ""
for k in range(1, len(path)):
for value in tree_node_dic[path[k]].values:
word = word + tokens[value - 1] + ' '
edges.append(Edge(word.strip(), index_node_dic[n1], index_node_dic[n2]))
return edges
def render(maze: Maze, solution: Solution = None, filename=None):
lw = ImageMazeRenderer.line_width
dlw = 2 * lw
def convert(maze_coord):
return dlw * maze_coord + dlw
img_size = convert(maze.n) + lw
image = Image.new('RGB', (img_size, img_size), color='black')
drawer = ImageDraw.Draw(image)
def as_box(e: Edge):
xr = {convert(vtx.x) for vtx in e.v}
yr = {convert(vtx.y) for vtx in e.v}
return min(xr), min(yr), max(xr) + 1, max(yr) + 1
def draw(*edges, color='white'):
for e in edges:
drawer.rectangle(as_box(e), fill=color)
entrance = Edge(Vertex(-1, 0), Vertex(0, 0))
the_exit = Edge(Vertex(maze.n - 1, maze.n - 1),
Vertex(maze.n, maze.n - 1))
draw(*maze.get_all_edges())
draw(entrance, the_exit)
if solution:
solution_color = 'limegreen'
draw(*solution.edges, color=solution_color)
draw(entrance, the_exit, color=solution_color)
image.save(build_output_path('jpg', file_name=filename), 'JPEG')
def saveEdge(self, edge: Edge) -> Edge:
col = self.getColl(edge.mapId)
result = col.insert_one(edge.toDBMap())
edge.id = str(result.inserted_id)
pointDao.addAdjacence(edge.pointA['id'], edge.mapId, edge.pointB['id'])
pointDao.addAdjacence(edge.pointB['id'], edge.mapId, edge.pointA['id'])
return edge
def updateEdge(self, edge: Edge) -> Edge:
if len(edge.id) != 24:
return edge
col = self.getColl(edge.mapId)
result = col.update_one({'_id': ObjectId(edge.id)},
{'$set': edge.toDBMap()},
upsert=True)
if result.upserted_id:
edge.id = str(result.upserted_id)
return edge
def build_cell_edges(site: Site) -> [Edge]:
edges = []
previous_corner = None
for corner in site.cell_corners:
if previous_corner is None:
pass
else:
edges.append(
Edge(previous_corner[0], previous_corner[1], corner[0],
corner[1]))
previous_corner = corner
edges.append(
Edge(previous_corner[0], previous_corner[1], site.cell_corners[0][0],
site.cell_corners[0][1]))
return edges
def finalize(self, last_row_summary):
"""satisfying last row post-conditions: no isolated regions should be left"""
row = last_row_summary
for j in range(1, len(row.vertices)):
le, ri = row.vertices[j - 1], row.vertices[j]
if not row.uf.connected(le, ri):
row.uf.connect(le, ri)
self.maze.add_edge(Edge(le, ri))
def dive(vtx):
visited.add(vtx)
next_candidates = [n for n in self._get_neighbours(vtx) if n not in visited]
if not next_candidates:
return
nxt = self.random.choice(next_candidates)
self.maze.add_edge(Edge(vtx, nxt))
stack.append(nxt)
dive(nxt)
def save(self, pointAId: str, pointBId: str, edgeWidth: float,
mapId: str) -> Edge:
pointA = pointDao.findById(pointAId, mapId)
pointB = pointDao.findById(pointBId, mapId)
if mapId is None:
mapId = pointA.mapId
edge = Edge(mapId,
pointA.toJsonMap(),
pointB.toJsonMap(),
edgeWidth=edgeWidth)
return edgeDao.saveEdge(edge)
def compute_site_coverage(site: Site):
cell_area = compute_polygon_area(site.cell_corners)
circle_intersection_edges = []
for edge in build_cell_edges(site):
# Take the edge as an infinite line
edge_line_circle_intersection_points = circle_line_segment_intersection(
(edge.x_start, edge.y_start), (edge.x_end, edge.y_end), site)
# List all edges that intersect the circle
if edge_line_circle_intersection_points is not None:
circle_intersection_edges.append(
Edge(edge_line_circle_intersection_points[0][0],
edge_line_circle_intersection_points[0][1],
edge_line_circle_intersection_points[1][0],
edge_line_circle_intersection_points[1][1]))
# Generate every possible edge pairs
for pair in itertools.combinations(circle_intersection_edges, 2):
segment_a = pair[0]
segment_b = pair[1]
segments_intersection_point_exists = segment_intersects(
(segment_a.x_start, segment_a.y_start),
(segment_a.x_end, segment_a.y_end),
(segment_b.x_start, segment_b.y_start),
(segment_b.x_end, segment_b.y_end))
if segments_intersection_point_exists:
segments_intersection_point = intersection(
line(segment_a.x_start, segment_a.y_start, segment_a.x_end,
segment_a.y_end),
line(segment_b.x_start, segment_b.y_start, segment_b.x_end,
segment_b.y_end))
# Check if they intersect in the circle
if compute_point_distance(
site.x, site.y, segments_intersection_point[0],
segments_intersection_point[1]) < site.coverage_radius:
# Update current edge point to put it on the cell edge (other edge will be updated on its iteration)
segment_a.define_edge_point_to_keep(
site, segment_b.origin_state, segments_intersection_point)
segment_b.define_edge_point_to_keep(
site, segment_a.origin_state, segments_intersection_point)
# This list will hold every group edges that are connected to each other
solo_edges = []
polygon_edges_groups = []
for group in list_connected_edges_group(circle_intersection_edges):
if len(group) == 1:
solo_edges.append(group[0])
else:
polygon_edges_groups.append(group)
groups_coverage_area = 0
unconnected_group_edges_end_pairs = []
for group in polygon_edges_groups:
groups_coverage_area += compute_polygon_area(
list_polygon_corners(group))
unconnected_edges = find_unconnected_edges_ends(group)
if len(unconnected_edges) > 0:
unconnected_group_edges_end_pairs.append(unconnected_edges)
if len(polygon_edges_groups) > 0:
# Now every unconnected group unconnected points pair will be chained by searching for the closer one
# This list holds tuples of points (which are also represented as tuples)
line_segment_area = 0
central_coverage_area = 0
if len(unconnected_group_edges_end_pairs) > 0:
linked_pair_list = [unconnected_group_edges_end_pairs[0]]
pairs_copy = copy.copy(unconnected_group_edges_end_pairs[1:])
while len(pairs_copy) > 0:
closer_pair = find_closer_point_pair_then_sort_pair(
linked_pair_list[len(linked_pair_list) - 1][1], pairs_copy)
linked_pair_list.append(closer_pair)
pairs_copy.remove(closer_pair)
# Unpack points into a list to compute central polygon area and also build the pair of points that will be used
# to compute segment circle area remaining
corners = []
segments_circle_points = []
for pair in linked_pair_list:
corners.append(pair[0])
corners.append(pair[1])
if len(segments_circle_points) == 0:
segments_circle_points.append([pair[1]])
else:
last_segment_circle_point_item = segments_circle_points[
len(segments_circle_points) - 1]
if len(last_segment_circle_point_item) == 1:
last_segment_circle_point_item.append(pair[0])
else:
segments_circle_points.append([pair[1]])
segments_circle_points[len(segments_circle_points) - 1].append(
linked_pair_list[0][0])
# Build central polygon if there is at least 2 connected edges groups -> meaning 4 corners
if len(corners) > 3:
central_coverage_area = compute_polygon_area(corners)
for chord in segments_circle_points:
line_segment_area += compute_circle_segment_area(
site.coverage_radius, chord[0], chord[1], site)
coverage_area = groups_coverage_area + central_coverage_area + line_segment_area
else:
# Handle case where no intersecting edges is met and the coverage is the full circle till now
coverage_area = compute_circle_area(site.coverage_radius)
# Remove every unconnected segment circle area from coverage area
for edge in solo_edges:
coverage_area -= compute_circle_segment_area(
site.coverage_radius, (edge.x_start, edge.y_start),
(edge.x_end, edge.y_end), site)
# Add tolerance to small overflow that could be due to floating point number precision not being perfectly accurate
if float("%.2f" % coverage_area) > float("%.2f" % cell_area):
raise Exception("Error in computing site coverage area")
return coverage_area
def connect(self, v1, v2):
assert not self.uf.connected(v1, v2) # preventing loops
self.uf.connect(v1, v2)
self.maze_gen.maze.add_edge(Edge(v1, v2))
def assebleEdge(self, item: dict) -> Edge:
edge = Edge(item['mapId'], item['pointA'], item['pointB'])
edge.id = str(item['_id'])
return edge