def add_points_on_rings(self, areas):
for polygon in areas:
for ring in (polygon.exterior, ) + tuple(polygon.interiors):
for linestring in assert_multilinestring(
ring.intersection(self.clear_geometry)):
coords = tuple(linestring.coords)
if len(coords) == 2:
path = Path(coords)
length = abs(
np.linalg.norm(path.vertices[0] -
path.vertices[1]))
for coord in tuple(
path.interpolated(int(length / 1.0 +
1)).vertices):
self.add_point(coord)
continue
start = 0
for segment in zip(coords[:-1], coords[1:]):
path = Path(segment)
length = abs(
np.linalg.norm(path.vertices[0] -
path.vertices[1]))
if length < 1.0:
coords = (path.vertices[1 if start == 0 else 0], )
else:
coords = tuple(
path.interpolated(int(length / 1.0 +
0.5)).vertices)[start:]
for coord in coords:
self.add_point(coord)
start = 1
def stair_areas(self):
left = []
for stair in assert_multilinestring(self.stairs):
left.append(
stair.parallel_offset(0.15,
'right',
join_style=JOIN_STYLE.mitre))
return cascaded_union(left).buffer(0.20,
join_style=JOIN_STYLE.mitre,
cap_style=CAP_STYLE.flat)
def collect_escalators(self):
self.mpl_escalatorslopes = ()
for escalatorslope_line in assert_multilinestring(self.level.geometries.escalatorslopes):
coords = tuple(escalatorslope_line.coords)
self.mpl_escalatorslopes += tuple((Path(part), coord_angle(*part))
for part in zip(coords[:-1], coords[1:]))
self._built_escalators = []
for escalator in self.level.escalators.all():
mpl_escalator = shapely_to_mpl(escalator.geometry)
for slope_line, angle in self.mpl_escalatorslopes:
if mpl_escalator.intersects_path(slope_line, filled=True):
self._built_escalators.append(EscalatorData(mpl_escalator, escalator.direction, slope_line, angle))
break
else:
print('Escalator %s has no slope line!' % escalator.name)
continue
def create_oneways(self):
oneways = self.level.geometries.oneways
oneways = assert_multilinestring(oneways)
segments = ()
for oneway in oneways:
coords = tuple(oneway.coords)
segments += tuple((Path(part), coord_angle(*part))
for part in zip(coords[:-1], coords[1:]))
for oneway, oneway_angle in segments:
line_string = LineString(tuple(oneway.vertices))
polygon = line_string.buffer(0.10, join_style=JOIN_STYLE.mitre, cap_style=CAP_STYLE.flat)
center = polygon.centroid
num_points = 0
connected_rooms = set()
points = []
for room in self.rooms:
if not polygon.intersects(room._built_geometry):
continue
for subpolygon in assert_multipolygon(polygon.intersection(room._built_geometry)):
connected_rooms.add(room)
nearest_point = get_nearest_point(room.clear_geometry, subpolygon.centroid)
point, = room.add_point(nearest_point.coords[0])
points.append(point)
if len(points) < 2:
print('oneway with <2 points (%d) detected at (%.2f, %.2f)' % (num_points, center.x, center.y))
continue
center_point = GraphPoint(center.x, center.y, None)
self._built_room_transfer_points.append(center_point)
for room in connected_rooms:
room._built_points.append(center_point)
for point in points:
angle = coord_angle(point.xy, center_point.xy)
angle_diff = ((oneway_angle - angle + 180) % 360) - 180
direction_up = (angle_diff > 0)
if direction_up:
point.connect_to(center_point)
else:
center_point.connect_to(point)
def recalculate(cls):
# collect location areas
all_areas = []
all_ramps = []
space_areas = {}
spaces = {}
levels = Level.objects.prefetch_related('buildings', 'doors', 'spaces', 'spaces__columns',
'spaces__obstacles', 'spaces__lineobstacles', 'spaces__holes',
'spaces__stairs', 'spaces__ramps', 'spaces__altitudemarkers')
logger = logging.getLogger('c3nav')
for level in levels:
areas = []
ramps = []
stairs = []
# collect all accessible areas on this level
buildings_geom = unary_union(tuple(building.geometry for building in level.buildings.all()))
for space in level.spaces.all():
spaces[space.pk] = space
space.orig_geometry = space.geometry
if space.outside:
space.geometry = space.geometry.difference(buildings_geom)
space_accessible = space.geometry.difference(
unary_union(tuple(c.geometry for c in space.columns.all()) +
tuple(o.geometry for o in space.obstacles.all()) +
tuple(o.buffered_geometry for o in space.lineobstacles.all()) +
tuple(h.geometry for h in space.holes.all()))
)
space_ramps = unary_union(tuple(r.geometry for r in space.ramps.all()))
areas.append(space_accessible.difference(space_ramps))
for geometry in assert_multipolygon(space_accessible.intersection(space_ramps)):
ramp = AltitudeArea(geometry=geometry, level=level)
ramp.geometry_prep = prepared.prep(geometry)
ramp.space = space.pk
ramps.append(ramp)
areas = tuple(orient(polygon) for polygon in assert_multipolygon(
unary_union(areas+list(door.geometry for door in level.doors.all()))
))
# collect all stairs on this level
for space in level.spaces.all():
space_buffer = space.geometry.buffer(0.001, join_style=JOIN_STYLE.mitre)
for stair in space.stairs.all():
stairs.extend(assert_multilinestring(
stair.geometry.intersection(space_buffer)
))
# divide areas using stairs
for stair in stairs:
areas = cut_polygon_with_line(areas, stair)
# create altitudearea objects
areas = [AltitudeArea(geometry=clean_cut_polygon(area), level=level)
for area in areas]
# prepare area geometries
for area in areas:
area.geometry_prep = prepared.prep(area.geometry)
# assign spaces to areas
space_areas.update({space.pk: [] for space in level.spaces.all()})
for area in areas:
area.spaces = set()
area.geometry_prep = prepared.prep(area.geometry)
for space in level.spaces.all():
if area.geometry_prep.intersects(space.geometry):
area.spaces.add(space.pk)
space_areas[space.pk].append(area)
# give altitudes to areas
for space in level.spaces.all():
for altitudemarker in space.altitudemarkers.all():
for area in space_areas[space.pk]:
if area.geometry_prep.contains(altitudemarker.geometry):
area.altitude = altitudemarker.altitude
break
else:
logger.error(
_('AltitudeMarker #%(marker_id)d in Space #%(space_id)d on Level %(level_label)s '
'is not placed in an accessible area') % {'marker_id': altitudemarker.pk,
'space_id': space.pk,
'level_label': level.short_label})
# determine altitude area connections
for area in areas:
area.connected_to = []
for area, other_area in combinations(areas, 2):
if area.geometry_prep.intersects(other_area.geometry):
area.connected_to.append(other_area)
other_area.connected_to.append(area)
# determine ramp connections
for ramp in ramps:
ramp.connected_to = []
buffered = ramp.geometry.buffer(0.001)
for area in areas:
if area.geometry_prep.intersects(buffered):
intersection = area.geometry.intersection(buffered)
ramp.connected_to.append((area, intersection))
if len(ramp.connected_to) != 2:
if len(ramp.connected_to) == 0:
logger.warning('Ramp with no connections!')
elif len(ramp.connected_to) == 1:
logger.warning('Ramp with only one connection!')
else:
logger.warning('Ramp with more than one connections!')
# add areas to global areas
all_areas.extend(areas)
all_ramps.extend(ramps)
# give temporary ids to all areas
areas = all_areas
ramps = all_ramps
for i, area in enumerate(areas):
area.tmpid = i
for area in areas:
area.connected_to = set(area.tmpid for area in area.connected_to)
for space in space_areas.keys():
space_areas[space] = set(area.tmpid for area in space_areas[space])
areas_without_altitude = set(area.tmpid for area in areas if area.altitude is None)
# interpolate altitudes
areas_with_altitude = [i for i in range(len(areas)) if i not in areas_without_altitude]
for i, tmpid in enumerate(areas_with_altitude):
areas[tmpid].i = i
csgraph = np.zeros((len(areas), len(areas)), dtype=bool)
for area in areas:
for connected_tmpid in area.connected_to:
csgraph[area.tmpid, connected_tmpid] = True
repeat = True
while repeat:
repeat = False
distances, predecessors = dijkstra(csgraph, directed=False, return_predecessors=True, unweighted=True)
np_areas_with_altitude = np.array(areas_with_altitude, dtype=np.uint32)
relevant_distances = distances[np_areas_with_altitude[:, None], np_areas_with_altitude]
# noinspection PyTypeChecker
for from_i, to_i in np.argwhere(np.logical_and(relevant_distances < np.inf, relevant_distances > 1)):
from_area = areas[areas_with_altitude[from_i]]
to_area = areas[areas_with_altitude[to_i]]
if from_area.altitude == to_area.altitude:
continue
path = [to_area.tmpid]
while path[-1] != from_area.tmpid:
path.append(predecessors[from_area.tmpid, path[-1]])
from_altitude = from_area.altitude
delta_altitude = (to_area.altitude-from_altitude)/(len(path)-1)
if set(path[1:-1]).difference(areas_without_altitude):
continue
for i, tmpid in enumerate(reversed(path[1:-1]), start=1):
area = areas[tmpid]
area.altitude = Decimal(from_altitude+delta_altitude*i).quantize(Decimal('1.00'))
areas_without_altitude.discard(tmpid)
area.i = len(areas_with_altitude)
areas_with_altitude.append(tmpid)
for from_tmpid, to_tmpid in zip(path[:-1], path[1:]):
csgraph[from_tmpid, to_tmpid] = False
csgraph[to_tmpid, from_tmpid] = False
repeat = True
# remaining areas: copy altitude from connected areas if any
repeat = True
while repeat:
repeat = False
for tmpid in tuple(areas_without_altitude):
area = areas[tmpid]
connected_with_altitude = area.connected_to-areas_without_altitude
if connected_with_altitude:
area.altitude = areas[next(iter(connected_with_altitude))].altitude
areas_without_altitude.discard(tmpid)
repeat = True
# remaining areas which belong to a room that has an altitude somewhere
for contained_areas in space_areas.values():
contained_areas_with_altitude = contained_areas - areas_without_altitude
contained_areas_without_altitude = contained_areas - contained_areas_with_altitude
if contained_areas_with_altitude and contained_areas_without_altitude:
altitude_areas = {}
for tmpid in contained_areas_with_altitude:
area = areas[tmpid]
altitude_areas.setdefault(area.altitude, []).append(area.geometry)
for altitude in altitude_areas.keys():
altitude_areas[altitude] = unary_union(altitude_areas[altitude])
for tmpid in contained_areas_without_altitude:
area = areas[tmpid]
area.altitude = min(altitude_areas.items(), key=lambda aa: aa[1].distance(area.geometry))[0]
areas_without_altitude.difference_update(contained_areas_without_altitude)
# last fallback: level base_altitude
for tmpid in areas_without_altitude:
area = areas[tmpid]
area.altitude = area.level.base_altitude
# prepare per-level operations
level_areas = {}
for area in areas:
level_areas.setdefault(area.level, set()).add(area.tmpid)
# make sure there is only one altitude area per altitude per level
for level in levels:
areas_by_altitude = {}
for tmpid in level_areas.get(level, []):
area = areas[tmpid]
areas_by_altitude.setdefault(area.altitude, []).append(area.geometry)
level_areas[level] = [AltitudeArea(level=level, geometry=unary_union(geometries), altitude=altitude)
for altitude, geometries in areas_by_altitude.items()]
# renumber joined areas
areas = list(chain(*(a for a in level_areas.values())))
for i, area in enumerate(areas):
area.tmpid = i
# finalize ramps
for ramp in ramps:
if not ramp.connected_to:
for area in space_areas[ramp.space]:
ramp.altitude = areas[area].altitude
break
else:
ramp.altitude = ramp.level.base_altitude
continue
if len(ramp.connected_to) == 1:
ramp.altitude = ramp.connected_to[0][0].altitude
continue
if len(ramp.connected_to) > 2:
ramp.connected_to = sorted(ramp.connected_to, key=lambda item: item[1].area)[-2:]
ramp.point1 = ramp.connected_to[0][1].centroid
ramp.point2 = ramp.connected_to[1][1].centroid
ramp.altitude = ramp.connected_to[0][0].altitude
ramp.altitude2 = ramp.connected_to[1][0].altitude
ramp.tmpid = len(areas)
areas.append(ramp)
level_areas[ramp.level].append(ramp)
#
# now fill in the obstacles and so on
#
for level in levels:
for space in level.spaces.all():
space.geometry = space.orig_geometry
buildings_geom = unary_union(tuple(b.geometry for b in level.buildings.all()))
doors_geom = unary_union(tuple(d.geometry for d in level.doors.all()))
space_geom = unary_union(tuple((s.geometry if not s.outside else s.geometry.difference(buildings_geom))
for s in level.spaces.all()))
accessible_area = unary_union((doors_geom, space_geom))
for space in level.spaces.all():
accessible_area = accessible_area.difference(space.geometry.intersection(
unary_union(tuple(h.geometry for h in space.holes.all()))
))
our_areas = level_areas.get(level, [])
for area in our_areas:
area.orig_geometry = area.geometry
area.orig_geometry_prep = prepared.prep(area.geometry)
stairs = []
for space in level.spaces.all():
space_geom = space.geometry
if space.outside:
space_geom = space_geom.difference(buildings_geom)
space_geom_prep = prepared.prep(space_geom)
holes_geom = unary_union(tuple(h.geometry for h in space.holes.all()))
remaining_space = (
tuple(o.geometry for o in space.obstacles.all()) +
tuple(o.buffered_geometry for o in space.lineobstacles.all())
)
remaining_space = tuple(g.intersection(space_geom).difference(holes_geom)
for g in remaining_space
if space_geom_prep.intersects(g))
remaining_space = tuple(chain(*(
assert_multipolygon(g) for g in remaining_space if not g.is_empty
)))
if not remaining_space:
continue
cuts = []
for cut in chain(*(assert_multilinestring(stair.geometry) for stair in space.stairs.all()),
(ramp.geometry.exterior for ramp in space.ramps.all())):
for coord1, coord2 in zip(tuple(cut.coords)[:-1], tuple(cut.coords)[1:]):
line = space_geom.intersection(LineString([coord1, coord2]))
if line.is_empty:
continue
factor = (line.length + 2) / line.length
line = scale(line, xfact=factor, yfact=factor)
centroid = line.centroid
line = min(assert_multilinestring(space_geom.intersection(line)),
key=lambda l: l.centroid.distance(centroid), default=None)
cuts.append(scale(line, xfact=1.01, yfact=1.01))
remaining_space = tuple(
orient(polygon) for polygon in remaining_space
)
for cut in cuts:
remaining_space = tuple(chain(*(cut_polygon_with_line(geom, cut)
for geom in remaining_space)))
remaining_space = MultiPolygon(remaining_space)
for polygon in assert_multipolygon(remaining_space):
polygon = clean_cut_polygon(polygon).buffer(0)
buffered = polygon.buffer(0.001)
center = polygon.centroid
touches = tuple((area, buffered.intersection(area.orig_geometry).area)
for area in our_areas
if area.orig_geometry_prep.intersects(buffered))
if touches:
min_touches = sum((t[1] for t in touches), 0)/4
area = max(touches, key=lambda item: (item[1] > min_touches,
item[0].altitude2 is not None,
item[0].altitude,
item[1]))[0]
else:
area = min(our_areas,
key=lambda a: a.orig_geometry.distance(center)-(0 if a.altitude2 is None else 0.6))
area.geometry = area.geometry.buffer(0).union(polygon)
for level in levels:
level_areas[level] = set(area.tmpid for area in level_areas.get(level, []))
# save to database
areas_to_save = set(range(len(areas)))
all_candidates = AltitudeArea.objects.select_related('level')
for candidate in all_candidates:
candidate.area = candidate.geometry.area
candidate.geometry_prep = prepared.prep(candidate.geometry)
all_candidates = sorted(all_candidates, key=attrgetter('area'), reverse=True)
num_modified = 0
num_deleted = 0
num_created = 0
field = AltitudeArea._meta.get_field('geometry')
for candidate in all_candidates:
new_area = None
if candidate.altitude2 is None:
for tmpid in level_areas.get(candidate.level, set()):
area = areas[tmpid]
if area.altitude2 is None and area.altitude == candidate.altitude:
new_area = area
break
else:
potential_areas = [areas[tmpid] for tmpid in level_areas.get(candidate.level, set())]
potential_areas = [area for area in potential_areas
if (candidate.altitude, candidate.altitude2) in ((area.altitude, area.altitude2),
(area.altitude2, area.altitude))]
potential_areas = [(area, area.geometry.intersection(candidate.geometry).area)
for area in potential_areas
if candidate.geometry_prep.intersects(area.geometry)]
if potential_areas:
new_area = max(potential_areas, key=itemgetter(1))[0]
if new_area is None:
candidate.delete()
num_deleted += 1
continue
if not field.get_final_value(new_area.geometry).almost_equals(candidate.geometry):
num_modified += 1
candidate.geometry = new_area.geometry
candidate.altitude = new_area.altitude
candidate.altitude2 = new_area.altitude2
candidate.point1 = new_area.point1
candidate.point2 = new_area.point2
candidate.save()
areas_to_save.discard(new_area.tmpid)
level_areas[new_area.level].discard(new_area.tmpid)
for tmpid in areas_to_save:
num_created += 1
areas[tmpid].save()
logger = logging.getLogger('c3nav')
logger.info(_('%d altitude areas built.') % len(areas))
logger.info(_('%(num_modified)d modified, %(num_deleted)d deleted, %(num_created)d created.') %
{'num_modified': num_modified, 'num_deleted': num_deleted, 'num_created': num_created})
def recalculate(cls):
# collect location areas
all_areas = []
all_ramps = []
space_areas = {}
spaces = {}
levels = Level.objects.prefetch_related('buildings', 'doors', 'spaces', 'spaces__columns',
'spaces__obstacles', 'spaces__lineobstacles', 'spaces__holes',
'spaces__stairs', 'spaces__ramps', 'spaces__altitudemarkers')
logger = logging.getLogger('c3nav')
for level in levels:
areas = []
ramps = []
stairs = []
# collect all accessible areas on this level
buildings_geom = unary_union(tuple(building.geometry for building in level.buildings.all()))
for space in level.spaces.all():
spaces[space.pk] = space
space.orig_geometry = space.geometry
if space.outside:
space.geometry = space.geometry.difference(buildings_geom)
space_accessible = space.geometry.difference(
unary_union(tuple(c.geometry for c in space.columns.all() if c.access_restriction_id is None) +
tuple(o.geometry for o in space.obstacles.all()) +
tuple(o.buffered_geometry for o in space.lineobstacles.all()) +
tuple(h.geometry for h in space.holes.all()))
)
space_ramps = unary_union(tuple(r.geometry for r in space.ramps.all()))
areas.append(space_accessible.difference(space_ramps))
for geometry in assert_multipolygon(space_accessible.intersection(space_ramps)):
ramp = AltitudeArea(geometry=geometry, level=level)
ramp.geometry_prep = prepared.prep(geometry)
ramp.space = space.pk
ramps.append(ramp)
areas = tuple(orient(polygon) for polygon in assert_multipolygon(
unary_union(areas+list(door.geometry for door in level.doors.all()))
))
# collect all stairs on this level
for space in level.spaces.all():
space_buffer = space.geometry.buffer(0.001, join_style=JOIN_STYLE.mitre)
for stair in space.stairs.all():
stairs.extend(assert_multilinestring(
stair.geometry.intersection(space_buffer)
))
# divide areas using stairs
for stair in stairs:
areas = cut_polygon_with_line(areas, stair)
# create altitudearea objects
areas = [AltitudeArea(geometry=clean_cut_polygon(area), level=level)
for area in areas]
# prepare area geometries
for area in areas:
area.geometry_prep = prepared.prep(area.geometry)
# assign spaces to areas
space_areas.update({space.pk: [] for space in level.spaces.all()})
for area in areas:
area.spaces = set()
area.geometry_prep = prepared.prep(area.geometry)
for space in level.spaces.all():
if area.geometry_prep.intersects(space.geometry):
area.spaces.add(space.pk)
space_areas[space.pk].append(area)
# give altitudes to areas
for space in level.spaces.all():
for altitudemarker in space.altitudemarkers.all():
for area in space_areas[space.pk]:
if area.geometry_prep.contains(altitudemarker.geometry):
area.altitude = altitudemarker.altitude
break
else:
logger.error(
_('AltitudeMarker #%(marker_id)d in Space #%(space_id)d on Level %(level_label)s '
'is not placed in an accessible area') % {'marker_id': altitudemarker.pk,
'space_id': space.pk,
'level_label': level.short_label})
# determine altitude area connections
for area in areas:
area.connected_to = []
for area, other_area in combinations(areas, 2):
if area.geometry_prep.intersects(other_area.geometry):
area.connected_to.append(other_area)
other_area.connected_to.append(area)
# determine ramp connections
for ramp in ramps:
ramp.connected_to = []
buffered = ramp.geometry.buffer(0.001)
for area in areas:
if area.geometry_prep.intersects(buffered):
intersection = area.geometry.intersection(buffered)
ramp.connected_to.append((area, intersection))
if len(ramp.connected_to) != 2:
if len(ramp.connected_to) == 0:
logger.warning('A ramp in space #%d has no connections!' % ramp.space)
elif len(ramp.connected_to) == 1:
logger.warning('A ramp in space #%d has only one connection!' % ramp.space)
else:
logger.warning('A ramp in space #%d has more than two connections!' % ramp.space)
# add areas to global areas
all_areas.extend(areas)
all_ramps.extend(ramps)
# give temporary ids to all areas
areas = all_areas
ramps = all_ramps
for i, area in enumerate(areas):
area.tmpid = i
for area in areas:
area.connected_to = set(area.tmpid for area in area.connected_to)
for space in space_areas.keys():
space_areas[space] = set(area.tmpid for area in space_areas[space])
areas_without_altitude = set(area.tmpid for area in areas if area.altitude is None)
# interpolate altitudes
areas_with_altitude = [i for i in range(len(areas)) if i not in areas_without_altitude]
for i, tmpid in enumerate(areas_with_altitude):
areas[tmpid].i = i
csgraph = np.zeros((len(areas), len(areas)), dtype=bool)
for area in areas:
for connected_tmpid in area.connected_to:
csgraph[area.tmpid, connected_tmpid] = True
repeat = True
while repeat:
repeat = False
distances, predecessors = dijkstra(csgraph, directed=False, return_predecessors=True, unweighted=True)
np_areas_with_altitude = np.array(areas_with_altitude, dtype=np.uint32)
relevant_distances = distances[np_areas_with_altitude[:, None], np_areas_with_altitude]
# noinspection PyTypeChecker
for from_i, to_i in np.argwhere(np.logical_and(relevant_distances < np.inf, relevant_distances > 1)):
from_area = areas[areas_with_altitude[from_i]]
to_area = areas[areas_with_altitude[to_i]]
if from_area.altitude == to_area.altitude:
continue
path = [to_area.tmpid]
while path[-1] != from_area.tmpid:
path.append(predecessors[from_area.tmpid, path[-1]])
from_altitude = from_area.altitude
delta_altitude = (to_area.altitude-from_altitude)/(len(path)-1)
if set(path[1:-1]).difference(areas_without_altitude):
continue
for i, tmpid in enumerate(reversed(path[1:-1]), start=1):
area = areas[tmpid]
area.altitude = Decimal(from_altitude+delta_altitude*i).quantize(Decimal('1.00'))
areas_without_altitude.discard(tmpid)
area.i = len(areas_with_altitude)
areas_with_altitude.append(tmpid)
for from_tmpid, to_tmpid in zip(path[:-1], path[1:]):
csgraph[from_tmpid, to_tmpid] = False
csgraph[to_tmpid, from_tmpid] = False
repeat = True
# remaining areas: copy altitude from connected areas if any
repeat = True
while repeat:
repeat = False
for tmpid in tuple(areas_without_altitude):
area = areas[tmpid]
connected_with_altitude = area.connected_to-areas_without_altitude
if connected_with_altitude:
area.altitude = areas[next(iter(connected_with_altitude))].altitude
areas_without_altitude.discard(tmpid)
repeat = True
# remaining areas which belong to a room that has an altitude somewhere
for contained_areas in space_areas.values():
contained_areas_with_altitude = contained_areas - areas_without_altitude
contained_areas_without_altitude = contained_areas - contained_areas_with_altitude
if contained_areas_with_altitude and contained_areas_without_altitude:
altitude_areas = {}
for tmpid in contained_areas_with_altitude:
area = areas[tmpid]
altitude_areas.setdefault(area.altitude, []).append(area.geometry)
for altitude in altitude_areas.keys():
altitude_areas[altitude] = unary_union(altitude_areas[altitude])
for tmpid in contained_areas_without_altitude:
area = areas[tmpid]
area.altitude = min(altitude_areas.items(), key=lambda aa: aa[1].distance(area.geometry))[0]
areas_without_altitude.difference_update(contained_areas_without_altitude)
# last fallback: level base_altitude
for tmpid in areas_without_altitude:
area = areas[tmpid]
area.altitude = area.level.base_altitude
# prepare per-level operations
level_areas = {}
for area in areas:
level_areas.setdefault(area.level, set()).add(area.tmpid)
# make sure there is only one altitude area per altitude per level
for level in levels:
areas_by_altitude = {}
for tmpid in level_areas.get(level, []):
area = areas[tmpid]
areas_by_altitude.setdefault(area.altitude, []).append(area.geometry)
level_areas[level] = [AltitudeArea(level=level, geometry=unary_union(geometries), altitude=altitude)
for altitude, geometries in areas_by_altitude.items()]
# renumber joined areas
areas = list(chain(*(a for a in level_areas.values())))
for i, area in enumerate(areas):
area.tmpid = i
# finalize ramps
for ramp in ramps:
if not ramp.connected_to:
for area in space_areas[ramp.space]:
ramp.altitude = areas[area].altitude
break
else:
ramp.altitude = ramp.level.base_altitude
continue
if len(ramp.connected_to) == 1:
ramp.altitude = ramp.connected_to[0][0].altitude
continue
if len(ramp.connected_to) > 2:
ramp.connected_to = sorted(ramp.connected_to, key=lambda item: item[1].area)[-2:]
ramp.point1 = ramp.connected_to[0][1].centroid
ramp.point2 = ramp.connected_to[1][1].centroid
ramp.altitude = ramp.connected_to[0][0].altitude
ramp.altitude2 = ramp.connected_to[1][0].altitude
ramp.tmpid = len(areas)
areas.append(ramp)
level_areas[ramp.level].append(ramp)
#
# now fill in the obstacles and so on
#
for level in levels:
for space in level.spaces.all():
space.geometry = space.orig_geometry
buildings_geom = unary_union(tuple(b.geometry for b in level.buildings.all()))
doors_geom = unary_union(tuple(d.geometry for d in level.doors.all()))
space_geom = unary_union(tuple((s.geometry if not s.outside else s.geometry.difference(buildings_geom))
for s in level.spaces.all()))
accessible_area = unary_union((doors_geom, space_geom))
for space in level.spaces.all():
accessible_area = accessible_area.difference(space.geometry.intersection(
unary_union(tuple(h.geometry for h in space.holes.all()))
))
our_areas = level_areas.get(level, [])
for area in our_areas:
area.orig_geometry = area.geometry
area.orig_geometry_prep = prepared.prep(area.geometry)
stairs = []
for space in level.spaces.all():
space_geom = space.geometry
if space.outside:
space_geom = space_geom.difference(buildings_geom)
space_geom_prep = prepared.prep(space_geom)
holes_geom = unary_union(tuple(h.geometry for h in space.holes.all()))
remaining_space = (
tuple(o.geometry for o in space.obstacles.all()) +
tuple(o.buffered_geometry for o in space.lineobstacles.all())
)
remaining_space = tuple(g.intersection(space_geom).difference(holes_geom)
for g in remaining_space
if space_geom_prep.intersects(g))
remaining_space = tuple(chain(*(
assert_multipolygon(g) for g in remaining_space if not g.is_empty
)))
if not remaining_space:
continue
cuts = []
for cut in chain(*(assert_multilinestring(stair.geometry) for stair in space.stairs.all()),
(ramp.geometry.exterior for ramp in space.ramps.all())):
for coord1, coord2 in zip(tuple(cut.coords)[:-1], tuple(cut.coords)[1:]):
line = space_geom.intersection(LineString([coord1, coord2]))
if line.is_empty:
continue
factor = (line.length + 2) / line.length
line = scale(line, xfact=factor, yfact=factor)
centroid = line.centroid
line = min(assert_multilinestring(space_geom.intersection(line)),
key=lambda l: l.centroid.distance(centroid), default=None)
cuts.append(scale(line, xfact=1.01, yfact=1.01))
remaining_space = tuple(
orient(polygon) for polygon in remaining_space
)
for cut in cuts:
remaining_space = tuple(chain(*(cut_polygon_with_line(geom, cut)
for geom in remaining_space)))
remaining_space = MultiPolygon(remaining_space)
for polygon in assert_multipolygon(remaining_space):
polygon = clean_cut_polygon(polygon).buffer(0)
buffered = polygon.buffer(0.001)
center = polygon.centroid
touches = tuple((area, buffered.intersection(area.orig_geometry).area)
for area in our_areas
if area.orig_geometry_prep.intersects(buffered))
if touches:
min_touches = sum((t[1] for t in touches), 0)/4
area = max(touches, key=lambda item: (item[1] > min_touches,
item[0].altitude2 is not None,
item[0].altitude,
item[1]))[0]
else:
area = min(our_areas,
key=lambda a: a.orig_geometry.distance(center)-(0 if a.altitude2 is None else 0.6))
area.geometry = area.geometry.buffer(0).union(polygon)
for level in levels:
level_areas[level] = set(area.tmpid for area in level_areas.get(level, []))
# save to database
areas_to_save = set(range(len(areas)))
all_candidates = AltitudeArea.objects.select_related('level')
for candidate in all_candidates:
candidate.area = candidate.geometry.area
candidate.geometry_prep = prepared.prep(candidate.geometry)
all_candidates = sorted(all_candidates, key=attrgetter('area'), reverse=True)
num_modified = 0
num_deleted = 0
num_created = 0
field = AltitudeArea._meta.get_field('geometry')
for candidate in all_candidates:
new_area = None
if candidate.altitude2 is None:
for tmpid in level_areas.get(candidate.level, set()):
area = areas[tmpid]
if area.altitude2 is None and area.altitude == candidate.altitude:
new_area = area
break
else:
potential_areas = [areas[tmpid] for tmpid in level_areas.get(candidate.level, set())]
potential_areas = [area for area in potential_areas
if (candidate.altitude, candidate.altitude2) in ((area.altitude, area.altitude2),
(area.altitude2, area.altitude))]
potential_areas = [(area, area.geometry.intersection(candidate.geometry).area)
for area in potential_areas
if candidate.geometry_prep.intersects(area.geometry)]
if potential_areas:
new_area = max(potential_areas, key=itemgetter(1))[0]
if new_area is None:
candidate.delete()
num_deleted += 1
continue
if not field.get_final_value(new_area.geometry).almost_equals(candidate.geometry):
num_modified += 1
candidate.geometry = new_area.geometry
candidate.altitude = new_area.altitude
candidate.altitude2 = new_area.altitude2
candidate.point1 = new_area.point1
candidate.point2 = new_area.point2
candidate.save()
areas_to_save.discard(new_area.tmpid)
level_areas[new_area.level].discard(new_area.tmpid)
for tmpid in areas_to_save:
num_created += 1
areas[tmpid].save()
logger = logging.getLogger('c3nav')
logger.info(_('%d altitude areas built.') % len(areas))
logger.info(_('%(num_modified)d modified, %(num_deleted)d deleted, %(num_created)d created.') %
{'num_modified': num_modified, 'num_deleted': num_deleted, 'num_created': num_created})
def collect_stairs(self):
self.mpl_stairs = ()
for stair_line in assert_multilinestring(self.level.geometries.stairs):
coords = tuple(stair_line.coords)
self.mpl_stairs += tuple((Path(part), coord_angle(*part)) for part in zip(coords[:-1], coords[1:]))
def collect_oneways(self):
self._built_oneways = ()
for oneway_line in assert_multilinestring(self.level.geometries.oneways):
coords = tuple(oneway_line.coords)
self._built_oneways += tuple((Path(part), coord_angle(*part))
for part in zip(coords[:-1], coords[1:]))
