respect access restrictions in renderer

src/c3nav/mapdata/render/__init__.py

@@ -1 +1 @@
-from c3nav.mapdata.render.svg import render_svg  # noqa
+from c3nav.mapdata.render.svg import SVGRenderer  # noqa

src/c3nav/mapdata/render/base.py

@@ -21,6 +21,7 @@ class LevelGeometries:
         self.walls = None
         self.doors = None
         self.holes = None
+        self.access_restriction_affected = None
 
     @staticmethod
     def crop(self, geometry, crop_to):
@@ -51,12 +52,18 @@ class LevelGeometries:
             if level.on_top_of_id is None:
                 geoms.holes = spaces_geom.difference(walkable_geom)
 
+            access_restriction_affected = {}
+
             colors = {}
             for space in level.spaces.all():
                 access_restriction = space.access_restriction_id
+                if access_restriction is not None:
+                    access_restriction_affected.setdefault(access_restriction, []).append(space.geometry)
                 colors.setdefault(space.get_color(), {}).setdefault(access_restriction, []).append(space.geometry)
                 for area in space.areas.all():
                     access_restriction = area.access_restriction_id or space.access_restriction_id
+                    if access_restriction is not None:
+                        access_restriction_affected.setdefault(access_restriction, []).append(area.geometry)
                     colors.setdefault(area.get_color(), {}).setdefault(access_restriction, []).append(area.geometry)
             colors.pop(None, None)
 
@@ -72,6 +79,9 @@ class LevelGeometries:
                 altitudearea_colors = {color: areas for color, areas in altitudearea_colors.items() if areas}
                 geoms.altitudeareas.append(AltitudeAreaGeometries(altitudearea, altitudearea_colors))
 
+            geoms.access_restriction_affected = {access_restriction: unary_union(areas)
+                                                 for access_restriction, areas in access_restriction_affected.items()}
+
             geoms.walls = buildings_geom.difference(spaces_geom).difference(doors_geom)
             level.geoms_cache = pickle.dumps(geoms)
             level.save()
@@ -81,8 +91,8 @@ class LevelGeometries:
                 level.save()
 
 
-def get_render_level_data(level):
+def get_level_render_data(level):
-    cache_key = 'mapdata:render_level_data:%s:%s' % (str(level.pk if isinstance(level, Level) else level),
+    cache_key = 'mapdata:level_render_data:%s:%s' % (str(level.pk if isinstance(level, Level) else level),
                                                      MapUpdate.cache_key())
     result = cache.get(cache_key, None)
     if result is not None:

src/c3nav/mapdata/render/svg.py

@@ -1,50 +1,88 @@
+from django.utils.functional import cached_property
 from shapely.geometry import box
 from shapely.ops import unary_union
 
-from c3nav.mapdata.render.base import get_render_level_data
+from c3nav.mapdata.render.base import get_level_render_data
 from c3nav.mapdata.utils.svg import SVGImage
 
 
-def render_svg(level, miny, minx, maxy, maxx, scale=1):
+class SVGRenderer:
-    svg = SVGImage(bounds=((miny, minx), (maxy, maxx)), scale=scale, buffer=1)
+    def __init__(self, level, miny, minx, maxy, maxx, scale=1, user=None):
+        self.level = level
+        self.miny = miny
+        self.minx = minx
+        self.maxy = maxy
+        self.maxx = maxx
+        self.scale = scale
+        self.user = user
 
-    within_coords = (minx-1, miny-1, maxx+1, maxy+1)
+    @cached_property
-    bbox = box(*within_coords)
+    def bbox(self):
+        return box(self.minx-1, self.miny-1, self.maxx+1, self.maxy+1)
 
-    render_level_data = get_render_level_data(level)
+    @cached_property
+    def level_render_data(self):
+        return get_level_render_data(self.level)
 
-    crop_to = None
+    def check_level(self):
-    primary_level_count = 0
+        return self.level_render_data
-    for geoms, default_height in reversed(render_level_data):
-        if geoms.holes is not None:
-            primary_level_count += 1
 
-        geoms.crop_to = crop_to if primary_level_count > 1 else None
+    @cached_property
+    def affected_access_restrictions(self):
+        access_restrictions = set()
+        for geoms, default_height in self.level_render_data:
+            for access_restriction, area in geoms.access_restriction_affected.items():
+                if access_restriction not in access_restrictions and area.intersects(self.bbox):
+                    access_restrictions.add(access_restriction)
+        return access_restrictions
 
-        if geoms.holes is not None:
+    @cached_property
-            if crop_to is None:
+    def unlocked_access_restrictions(self):
-                crop_to = geoms.holes
+        # todo access_restriction
-            else:
+        return set(access_restriction for access_restriction in self.affected_access_restrictions
-                crop_to = crop_to.intersection(geoms.holes)
+                   if self.user is not None and self.user.is_superuser)
 
-    for geoms, default_height in render_level_data:
+    @cached_property
-        crop_to = bbox
+    def access_cache_key(self):
-        if geoms.crop_to is not None:
+        return '_'.join(str(i) for i in sorted(self.unlocked_access_restrictions)) or '0'
-            crop_to = crop_to.intersection(geoms.crop_to)
 
-        for altitudearea in geoms.altitudeareas:
+    def render(self):
-            svg.add_geometry(crop_to.intersection(altitudearea.geometry),
+        svg = SVGImage(bounds=((self.miny, self.minx), (self.maxy, self.maxx)), scale=self.scale, buffer=1)
-                             fill_color='#eeeeee', altitude=altitudearea.altitude)
 
-            for color, areas in altitudearea.colors.items():
+        unlocked_access_restrictions = self.unlocked_access_restrictions | set([None])
-                # todo access_restriction
-                areas = [area for area in areas.values()]
-                if areas:
-                    svg.add_geometry(crop_to.intersection(unary_union(areas)), fill_color=color, elevation=0)
 
-        svg.add_geometry(crop_to.intersection(geoms.walls),
+        crop_to = None
-                         fill_color='#aaaaaa', stroke_px=0.5, stroke_color='#aaaaaa', elevation=default_height)
+        primary_level_count = 0
+        for geoms, default_height in reversed(self.level_render_data):
+            if geoms.holes is not None:
+                primary_level_count += 1
 
-        svg.add_geometry(crop_to.intersection(geoms.doors), fill_color='#ffffff', elevation=0)
+            geoms.crop_to = crop_to if primary_level_count > 1 else None
 
-    return svg
+            if geoms.holes is not None:
+                if crop_to is None:
+                    crop_to = geoms.holes
+                else:
+                    crop_to = crop_to.intersection(geoms.holes)
+
+        for geoms, default_height in self.level_render_data:
+            crop_to = self.bbox
+            if geoms.crop_to is not None:
+                crop_to = crop_to.intersection(geoms.crop_to)
+
+            for altitudearea in geoms.altitudeareas:
+                svg.add_geometry(crop_to.intersection(altitudearea.geometry),
+                                 fill_color='#eeeeee', altitude=altitudearea.altitude)
+
+                for color, areas in altitudearea.colors.items():
+                    areas = tuple(area for access_restriction, area in areas.items()
+                                  if access_restriction in unlocked_access_restrictions)
+                    if areas:
+                        svg.add_geometry(crop_to.intersection(unary_union(areas)), fill_color=color, elevation=0)
+
+            svg.add_geometry(crop_to.intersection(geoms.walls),
+                             fill_color='#aaaaaa', stroke_px=0.5, stroke_color='#aaaaaa', elevation=default_height)
+
+            svg.add_geometry(crop_to.intersection(geoms.doors), fill_color='#ffffff', elevation=0)
+
+        return svg

src/c3nav/mapdata/views.py

@@ -2,7 +2,7 @@ from django.http import Http404, HttpResponse
 from shapely.geometry import box
 
 from c3nav.mapdata.models import Level, Source
-from c3nav.mapdata.render import render_svg
+from c3nav.mapdata.render.svg import SVGRenderer
 
 
 def tile(request, level, zoom, x, y, format):
@@ -22,11 +22,17 @@ def tile(request, level, zoom, x, y, format):
     if not box(bounds[0][1], bounds[0][0], bounds[1][1], bounds[1][0]).intersects(box(minx, miny, maxx, maxy)):
         raise Http404
 
+    renderer = SVGRenderer(level, miny, minx, maxy, maxx, scale=2**zoom, user=request.user)
+
     try:
-        svg = render_svg(level, miny, minx, maxy, maxx, scale=2**zoom)
+        renderer.check_level()
     except Level.DoesNotExist:
         raise Http404
 
+    print(renderer.access_cache_key)
+
+    svg = renderer.render()
+
     if format == 'svg':
         response = HttpResponse(svg.get_xml(), 'image/svg+xml')
     elif format == 'png':