2025-summer/team-3
12
Fork 0
Code Issues Pull requests Projects Releases Activity

rendermap: render a public and a non-public version of the map

Browse source
This commit is contained in:
Laura Klünder 2016-12-13 19:16:51 +01:00
parent 9c202ab6cd
commit 237b89dcc8
4 changed files with 75 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

50
src/c3nav/mapdata/models/level.py
View file

@ -26,9 +26,13 @@ class Level(MapItem):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@cached_property
def public_geometries(self):
return LevelGeometries.by_level(self, only_public=True)
@cached_property
def geometries(self):
return LevelGeometries.by_level(self)
return LevelGeometries.by_level(self, only_public=False)
def tofilename(self):
return 'levels/%s.json' % self.name
@ -75,19 +79,29 @@ class LevelGeometries():
by_level_name = {}
@classmethod
def by_level(cls, level):
return cls.by_level_name.setdefault(level.name, cls(level))
def by_level(cls, level, only_public=True):
return cls.by_level_name.setdefault((level.name, only_public), cls(level, only_public=only_public))
def __init__(self, level):
def __init__(self, level, only_public=True):
self.level = level
self.only_public = only_public
from c3nav.mapdata.permissions import get_public_packages
self.public_packages = get_public_packages()
def query(self, name):
queryset = getattr(self.level, name)
if not self.only_public:
return queryset.all()
return queryset.filter(package__in=self.public_packages)
@cached_property
def raw_rooms(self):
return cascaded_union([room.geometry for room in self.level.rooms.all()])
return cascaded_union([room.geometry for room in self.query('rooms')])
@cached_property
def buildings(self):
result = cascaded_union([building.geometry for building in self.level.buildings.all()])
result = cascaded_union([building.geometry for building in self.query('buildings')])
if self.level.intermediate:
result = cascaded_union([result, self.raw_rooms])
return result
@ -98,7 +112,7 @@ class LevelGeometries():
@cached_property
def outsides(self):
return cascaded_union([outside.geometry for outside in self.level.outsides.all()]).difference(self.buildings)
return cascaded_union([outside.geometry for outside in self.query('outsides')]).difference(self.buildings)
@cached_property
def mapped(self):
@ -107,21 +121,21 @@ class LevelGeometries():
@cached_property
def lineobstacles(self):
lineobstacles = []
for obstacle in self.level.lineobstacles.all():
for obstacle in self.query('lineobstacles'):
lineobstacles.append(obstacle.geometry.buffer(obstacle.width/2,
join_style=JOIN_STYLE.mitre, cap_style=CAP_STYLE.flat))
return cascaded_union(lineobstacles)
@cached_property
def uncropped_obstacles(self):
obstacles = [obstacle.geometry for obstacle in self.level.obstacles.filter(crop_to_level__isnull=True)]
obstacles = [obstacle.geometry for obstacle in self.query('obstacles').filter(crop_to_level__isnull=True)]
return cascaded_union(obstacles).intersection(self.mapped)
@cached_property
def cropped_obstacles(self):
levels_by_name = {}
obstacles_by_crop_to_level = {}
for obstacle in self.level.obstacles.filter(crop_to_level__isnull=False):
for obstacle in self.query('obstacles').filter(crop_to_level__isnull=False):
level_name = obstacle.crop_to_level.name
levels_by_name.setdefault(level_name, obstacle.crop_to_level)
obstacles_by_crop_to_level.setdefault(level_name, []).append(obstacle.geometry)
@ -140,11 +154,11 @@ class LevelGeometries():
@cached_property
def raw_doors(self):
return cascaded_union([door.geometry for door in self.level.doors.all()]).intersection(self.mapped)
return cascaded_union([door.geometry for door in self.query('doors').all()]).intersection(self.mapped)
@cached_property
def elevatorlevels(self):
return cascaded_union([elevatorlevel.geometry for elevatorlevel in self.level.elevatorlevels.all()])
return cascaded_union([elevatorlevel.geometry for elevatorlevel in self.query('elevatorlevels').all()])
@cached_property
def areas(self):
@ -152,7 +166,7 @@ class LevelGeometries():
@cached_property
def holes(self):
return cascaded_union([holes.geometry for holes in self.level.holes.all()]).intersection(self.areas)
return cascaded_union([holes.geometry for holes in self.query('holes').all()]).intersection(self.areas)
@cached_property
def accessible(self):
@ -183,18 +197,18 @@ class LevelGeometries():
return self.raw_doors.difference(self.areas)
def get_levelconnectors(self, to_level=None):
queryset = self.level.levelconnectors.prefetch_related('levels')
queryset = self.query('levelconnectors').prefetch_related('levels')
if to_level is not None:
queryset = queryset.filter(levels=to_level)
return cascaded_union([levelconnector.geometry for levelconnector in queryset])
@cached_property
def levelconnectors(self):
return cascaded_union([levelconnector.geometry for levelconnector in self.level.levelconnectors])
return cascaded_union([levelconnector.geometry for levelconnector in self.query('levelconnectors')])
@cached_property
def intermediate_shadows(self):
qs = self.level.levelconnectors.prefetch_related('levels').filter(levels__altitude__lt=self.level.altitude)
qs = self.query('levelconnectors').prefetch_related('levels').filter(levels__altitude__lt=self.level.altitude)
connectors = cascaded_union([levelconnector.geometry for levelconnector in qs])
shadows = self.buildings.difference(connectors.buffer(0.4, join_style=JOIN_STYLE.mitre))
shadows = shadows.buffer(0.3)
@ -205,7 +219,7 @@ class LevelGeometries():
holes = self.holes.buffer(0.1, join_style=JOIN_STYLE.mitre)
shadows = holes.difference(self.holes.buffer(-0.3, join_style=JOIN_STYLE.mitre))
qs = self.level.levelconnectors.prefetch_related('levels').filter(levels__altitude__lt=self.level.altitude)
qs = self.query('levelconnectors').prefetch_related('levels').filter(levels__altitude__lt=self.level.altitude)
connectors = cascaded_union([levelconnector.geometry for levelconnector in qs])
shadows = shadows.difference(connectors.buffer(1.0, join_style=JOIN_STYLE.mitre))
@ -213,7 +227,7 @@ class LevelGeometries():
@cached_property
def stairs(self):
return cascaded_union([stair.geometry for stair in self.level.stairs.all()]).intersection(self.accessible)
return cascaded_union([stair.geometry for stair in self.query('stairs')]).intersection(self.accessible)
@cached_property
def stair_areas(self):

5
src/c3nav/mapdata/permissions.py
View file

@ -7,6 +7,11 @@ from c3nav.mapdata.models import Source
from c3nav.mapdata.utils.cache import get_packages_cached
def get_public_packages():
packages_cached = get_packages_cached()
return [packages_cached[name] for name in settings.PUBLIC_PACKAGES]
def get_unlocked_packages_names(request, packages_cached=None):
if packages_cached is None:
packages_cached = get_packages_cached()

4
src/c3nav/mapdata/render/__init__.py
View file

@ -3,9 +3,11 @@ from c3nav.mapdata.render.renderer import LevelRenderer, get_render_path # noqa
def render_all_levels(show_accessibles=False):
renderers = []
for level in Level.objects.all():
renderers.append(LevelRenderer(level))
renderers.append(LevelRenderer(level, only_public=False))
renderers.append(LevelRenderer(level, only_public=True))
for renderer in renderers:
renderer.render_base(show_accessibles=show_accessibles)

60
src/c3nav/mapdata/render/renderer.py
View file

@ -23,8 +23,18 @@ def get_dimensions():
class LevelRenderer():
def __init__(self, level):
def __init__(self, level, only_public):
self.level = level
self.only_public = only_public
self.geometries = self.get_geometries(level)
def get_geometries(self, level):
return level.public_geometries if self.only_public else level.geometries
def get_filename(self, mode, filetype, level=None):
return get_render_path('%s%s-level-%s.%s' % (('public-' if self.only_public else ''), mode,
(self.level.name if level is None else level), filetype))
@staticmethod
def get_dimensions():
@ -103,32 +113,32 @@ class LevelRenderer():
MITRE = JOIN_STYLE.mitre
if not self.level.intermediate:
width, height = get_dimensions()
holes = self.level.geometries.holes.buffer(0.1, join_style=MITRE)
holes = self.geometries.holes.buffer(0.1, join_style=MITRE)
contents.append(self.polygon_svg(box(0, 0, width, height).difference(holes),
fill_color='#000000'))
contents.append(self.polygon_svg(self.level.geometries.buildings_with_holes,
contents.append(self.polygon_svg(self.geometries.buildings_with_holes,
fill_color='#D5D5D5'))
contents.append(self.polygon_svg(self.level.geometries.outsides_with_holes,
contents.append(self.polygon_svg(self.geometries.outsides_with_holes,
fill_color='#DCE6DC'))
contents.append(self.polygon_svg(self.level.geometries.stair_areas,
contents.append(self.polygon_svg(self.geometries.stair_areas,
fill_color='#000000',
fill_opacity=0.03))
contents.append(self.polygon_svg(self.level.geometries.stairs,
contents.append(self.polygon_svg(self.geometries.stairs,
stroke_color='#000000',
stroke_width=0.06,
stroke_opacity=0.2))
contents.append(self.polygon_svg(self.level.geometries.walls_shadow,
contents.append(self.polygon_svg(self.geometries.walls_shadow,
fill_color='#000000',
fill_opacity=0.06))
if show_accessibles:
narrowed_geometry = self.level.geometries.accessible.buffer(-0.6, join_style=MITRE)
clear_geometry = self.level.geometries.accessible.buffer(-0.3, join_style=JOIN_STYLE.mitre)
narrowed_geometry = self.geometries.accessible.buffer(-0.6, join_style=MITRE)
clear_geometry = self.geometries.accessible.buffer(-0.3, join_style=JOIN_STYLE.mitre)
wide_geometry = narrowed_geometry.buffer(0.31, join_style=MITRE).intersection(clear_geometry)
missing_geometry = clear_geometry.difference(wide_geometry.buffer(0.01, join_style=MITRE))
@ -144,35 +154,35 @@ class LevelRenderer():
fill_color='#FF9900',
fill_opacity=0.5))
contents.append(self.polygon_svg(self.level.geometries.elevatorlevels,
contents.append(self.polygon_svg(self.geometries.elevatorlevels,
fill_color='#9EF8FB'))
contents.append(self.polygon_svg(self.level.geometries.doors,
contents.append(self.polygon_svg(self.geometries.doors,
fill_color='#FFFFFF',
stroke_color='#3c3c3c',
stroke_width=0.05))
contents.append(self.polygon_svg(self.level.geometries.uncropped_obstacles,
contents.append(self.polygon_svg(self.geometries.uncropped_obstacles,
fill_color='#BDBDBD',
stroke_color='#9E9E9E',
stroke_width=0.05))
contents.append(self.polygon_svg(self.level.geometries.cropped_obstacles.buffer(-0.06, join_style=MITRE),
contents.append(self.polygon_svg(self.geometries.cropped_obstacles.buffer(-0.06, join_style=MITRE),
fill_color='#BDBDBD',
stroke_color='#9E9E9E',
stroke_width=0.05))
contents.append(self.polygon_svg(self.level.geometries.walls,
contents.append(self.polygon_svg(self.geometries.walls,
fill_color='#949494',
stroke_color='#3c3c3c',
stroke_width=0.05))
filename = get_render_path('level-%s.base.svg' % self.level.name)
filename = self.get_filename('base', 'svg')
with open(filename, 'w') as f:
f.write(ET.tostring(svg).decode())
if png:
png_filename = get_render_path('level-%s.base.png' % self.level.name)
png_filename = self.get_filename('base', 'png')
subprocess.call(['rsvg-convert', filename, '-o', png_filename])
def render_simple(self, png=True):
@ -193,7 +203,7 @@ class LevelRenderer():
fill_color='#000000'))
for level in dark_lower:
self.add_svg_image(svg, 'file://'+get_render_path('level-%s.base.png' % level.name))
self.add_svg_image(svg, 'file://'+self.get_filename('base', 'png', level=level))
contents = self.add_svg_content(svg)
contents.append(self.polygon_svg(box(0, 0, width, height),
@ -201,20 +211,20 @@ class LevelRenderer():
fill_opacity=0.1))
for level in lower:
self.add_svg_image(svg, 'file://'+get_render_path('level-%s.base.png' % level.name))
self.add_svg_image(svg, 'file://'+self.get_filename('base', 'png', level=level))
filename = get_render_path('level-%s.simple.svg' % self.level.name)
filename = self.get_filename('simple', 'svg')
with open(filename, 'w') as f:
f.write(ET.tostring(svg).decode())
if png:
png_filename = get_render_path('level-%s.simple.png' % self.level.name)
png_filename = self.get_filename('simple', 'png')
subprocess.call(['rsvg-convert', filename, '-o', png_filename])
def render_full(self, png=True):
svg = self.create_svg()
self.add_svg_image(svg, 'file://' + get_render_path('level-%s.simple.png' % self.level.name))
self.add_svg_image(svg, 'file://' + self.get_filename('simple', 'png'))
higher = []
for level in self.level.higher():
@ -224,17 +234,17 @@ class LevelRenderer():
contents = self.add_svg_content(svg)
for level in higher:
contents.append(self.polygon_svg(level.geometries.intermediate_shadows,
contents.append(self.polygon_svg(self.get_geometries(level).intermediate_shadows,
fill_color='#000000',
fill_opacity=0.07))
for level in higher:
self.add_svg_image(svg, 'file://'+get_render_path('level-%s.base.png' % level.name))
self.add_svg_image(svg, 'file://'+self.get_filename('base', 'png', level=level))
filename = get_render_path('level-%s.full.svg' % self.level.name)
filename = self.get_filename('full', 'svg')
with open(filename, 'w') as f:
f.write(ET.tostring(svg).decode())
if png:
png_filename = get_render_path('level-%s.full.png' % self.level.name)
png_filename = self.get_filename('full', 'png')
subprocess.call(['rsvg-convert', filename, '-o', png_filename])