FMVLayer endpoints

Author: BryonLewis

docker-compose.override.yml

@@ -16,6 +16,7 @@ services:
       - postgres
       - rabbitmq
       - minio
+    platform: 'linux/amd64'
 
   celery:
     build:

uvdat/core/models/map_layers.py

@@ -136,18 +136,21 @@ def get_ground_frame_mapping(self) -> dict:
             geom = feature.geometry
 
             if geom.geom_type == "Polygon":
-                coords = list(geom.exterior.coords)
-                if len(coords) >= 4:
-                    # Return first 4 unique corners, not repeating the closing point
-                    result[frame_id] = coords[:4]
+                # Access first ring (exterior) without using .exterior
+                if len(geom) > 0:
+                    coords = list(geom[0].coords)
+                    if len(coords) >= 4:
+                        result[frame_id] = coords[:4]
+
             elif geom.geom_type == "MultiPolygon":
-                # Pick the largest polygon by area, then return its first 4 corners
-                largest = max(geom, key=lambda p: p.area)
-                coords = list(largest.exterior.coords)
-                if len(coords) >= 4:
-                    result[frame_id] = coords[:4]
+                # Find largest polygon and access its first ring
+                largest = max(geom.geoms, key=lambda p: p.area)
+                if len(largest) > 0:
+                    coords = list(largest[0].coords)
+                    if len(coords) >= 4:
+                        result[frame_id] = coords[:4]
+
             else:
-                # Optional: log or skip unexpected geometries
                 continue
 
         return result

uvdat/core/rest/__init__.py

@@ -15,6 +15,7 @@
 from .tasks import TasksAPIView
 from .user import UserViewSet
 from .vector_feature_table_data import VectorFeatureTableDataViewSet
+from .fmv import FMVLayerViewSet
 
 __all__ = [
     ContextViewSet,
@@ -40,4 +41,5 @@
     TasksAPIView,
     MetadataFilterViewSet,
     DisplayConfigurationViewSet,
+    FMVLayerViewSet,
 ]

uvdat/core/rest/fmv.py

@@ -0,0 +1,106 @@
+from django.db import connection
+from django.http import HttpResponse
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.viewsets import ViewSet
+from django.core.files.storage import default_storage
+
+from uvdat.core.models import FMVLayer
+
+FMV_TILE_SQL = """
+WITH tile_bounds AS (
+    SELECT ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326) AS te
+),
+tilenvbounds as (
+    SELECT
+        ST_XMin(te) as xmin,
+        ST_YMin(te) as ymin,
+        ST_XMax(te) as xmax,
+        ST_YMax(te) as ymax,
+        (ST_XMax(te) - ST_XMin(te)) / 4 as segsize
+    FROM tile_bounds
+),
+env as (
+    SELECT ST_Segmentize(
+        ST_MakeEnvelope(
+            xmin,
+            ymin,
+            xmax,
+            ymax,
+            4326
+        ),
+        segsize
+    ) as seg
+    FROM tilenvbounds
+),
+bounds as (
+    SELECT
+        seg as geom,
+        seg::box2d as b2d
+    FROM env
+),
+vector_features AS (
+    SELECT
+        ST_AsMVTGeom(
+            ST_Transform(geometry, 3857),
+            ST_Transform((SELECT geom from bounds), 3857)
+        ) as geom,
+        map_layer_id,
+        id as fmvvectorfeatureid,
+        properties
+    FROM core_fmvvectorfeature
+    WHERE ST_Intersects(geometry, (SELECT geom from bounds))
+    AND map_layer_id = %(map_layer_id)s
+)
+SELECT ST_AsMVT(vector_features.*) AS mvt FROM vector_features;
+"""
+
+class FMVLayerViewSet(ViewSet):
+    """
+    ViewSet for accessing FMVLayer data and tiles.
+    """
+    def retrieve(self, request, pk=None):
+        try:
+            layer = FMVLayer.objects.get(pk=pk)
+        except FMVLayer.DoesNotExist:
+            return Response({"detail": "Not found."}, status=404)
+
+        presigned_url = None
+        if layer.fmv_video and hasattr(layer.fmv_video, 'name'):
+            presigned_url = default_storage.url(layer.fmv_video.name)
+        else:
+            presigned_url = None
+        data = {
+            "id": layer.id,
+            "name": layer.name,
+            "bbox": list(layer.bounds.extent) if layer.bounds else None,
+            "frameId_to_bbox": layer.get_ground_frame_mapping(),
+            "fmv_video_url": presigned_url
+        }
+        return Response(data)
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path=r'tiles/(?P<z>\d+)/(?P<x>\d+)/(?P<y>\d+)',
+        url_name='fmv_tiles',
+    )
+    def get_vector_tile(self, request, pk=None, x=None, y=None, z=None):
+        with connection.cursor() as cursor:
+            cursor.execute(
+                FMV_TILE_SQL,
+                {
+                    'z': z,
+                    'x': x,
+                    'y': y,
+                    'map_layer_id': pk,
+                },
+            )
+            row = cursor.fetchone()
+
+        tile = row[0]
+        return HttpResponse(
+            tile,
+            content_type='application/octet-stream',
+            status=200 if tile else 204,
+        )

uvdat/core/rest/map_layers.py

@@ -21,13 +21,16 @@
     RasterMapLayer,
     VectorFeature,
     VectorMapLayer,
+    FMVLayer,
+    FMVVectorFeature,
 )
 from uvdat.core.rest.serializers import (
     AbstractMapLayerSerializer,
     NetCDFLayerSerializer,
     RasterMapLayerSerializer,
     VectorMapLayerDetailSerializer,
     VectorMapLayerSerializer,
+    FMVLayerSerializer,
 )
 
 from .permissions import DefaultPermission
@@ -466,7 +469,8 @@ def create(self, request, *args, **kwargs):
             raster_layer = RasterMapLayer.objects.filter(id=layer_id).first()
             vector_layer = VectorMapLayer.objects.filter(id=layer_id).first()
             netcdf_layer = NetCDFLayer.objects.filter(id=layer_id).first()
-            map_layer = raster_layer or vector_layer or netcdf_layer
+            fmv_layer = FMVLayer.objects.filter(id=layer_id).first()
+            map_layer = raster_layer or vector_layer or netcdf_layer or fmv_layer
 
             if map_layer is None:
                 continue  # Skip if no layer is found for the provided ID
@@ -478,6 +482,8 @@ def create(self, request, *args, **kwargs):
                 serializer = VectorMapLayerSerializer(map_layer)
             elif isinstance(map_layer, NetCDFLayer):
                 serializer = NetCDFLayerSerializer(map_layer)
+            elif isinstance(map_layer, FMVLayer):
+                serializer = FMVLayerSerializer(map_layer)
             # Get the serialized data
             layer_response = serializer.data
             if raster_layer:
@@ -486,6 +492,8 @@ def create(self, request, *args, **kwargs):
                 layer_response['type'] = 'vector'
             elif netcdf_layer:
                 layer_response['type'] = 'netcdf'
+            elif fmv_layer:
+                layer_response['type'] = 'fmv'
 
             # Check for LayerRepresentation if provided
             if layer_representation_id is not None:
@@ -525,12 +533,14 @@ def list_all_map_layers(self, request, *args, **kwargs):
         raster_layers = RasterMapLayer.objects.all()
         vector_layers = VectorMapLayer.objects.all()
         netcdf_layers = NetCDFLayer.objects.all()
+        fmv_layers = FMVLayer.objects.all()
 
         # Serialize layers
         for map_layer, _serializer, layer_type in [
             (raster_layers, RasterMapLayerSerializer, 'raster'),
             (vector_layers, VectorMapLayerSerializer, 'vector'),
             (netcdf_layers, NetCDFLayerSerializer, 'netcdf'),
+            (fmv_layers, FMVLayer, 'fmv'),
         ]:
             for layer in map_layer:
                 serializer = AbstractMapLayerSerializer(layer)
@@ -577,6 +587,9 @@ def list(self, request, *args, **kwargs):
             if not map_layer and 'netcdf' == layer_type:
                 map_layer = NetCDFLayer.objects.filter(id=layer_id).first()
                 serializer_class = NetCDFLayerSerializer
+            if not map_layer and 'fmv' == layer_type:
+                map_layer = FMVLayer.objects.filter(id=layer_id).first()
+                serializer_class = FMVLayerSerializer
 
             if not map_layer:
                 continue  # Skip if no matching layer is found
@@ -619,6 +632,7 @@ def map_layer_bbox(self, request, *args, **kwargs):
         raster_map_layer_ids = request.query_params.getlist('rasterMapLayerIds')
         vector_map_layer_ids = request.query_params.getlist('vectorMapLayerIds')
         netcdf_map_layer_ids = request.query_params.getlist('netCDFMapLayerIds')
+        fmv_map_layer_ids = request.query_params.getlist('fmvMapLayerIds')
 
         # Initialize variables to track the overall bounding box
         overall_bbox = {
@@ -663,6 +677,17 @@ def map_layer_bbox(self, request, *args, **kwargs):
                 overall_bbox['ymin'] = min(overall_bbox['ymin'], netcdf_bbox[1])
                 overall_bbox['xmax'] = max(overall_bbox['xmax'], netcdf_bbox[2])
                 overall_bbox['ymax'] = max(overall_bbox['ymax'], netcdf_bbox[3])
+        if fmv_map_layer_ids:
+            fmv_bboxes = FMVVectorFeature.objects.filter(
+                map_layer_id__in=fmv_map_layer_ids
+            ).aggregate(extent=Extent('geometry'))['extent']
+
+            if vector_bboxes:
+                overall_bbox['xmin'] = min(overall_bbox['xmin'], vector_bboxes[0])
+                overall_bbox['ymin'] = min(overall_bbox['ymin'], vector_bboxes[1])
+                overall_bbox['xmax'] = max(overall_bbox['xmax'], vector_bboxes[2])
+                overall_bbox['ymax'] = max(overall_bbox['ymax'], vector_bboxes[3])
+
         # Check if the bbox values were updated; if not, return an error message
         if overall_bbox['xmin'] == float('inf'):
             return JsonResponse(
@@ -697,6 +722,8 @@ def update_name(self, request, *args, **kwargs):
                 RasterMapLayer.objects.filter(id=layer_id).update(name=new_name)
             elif layer_type == 'netcdf':
                 NetCDFData.objects.filter(id=layer_id).update(name=new_name)
+            elif layer_type == 'fmv':
+                FMVLayer.objects.filter(id=layer_id).update(name=new_name)
             else:
                 return Response(
                     {'error': 'Invalid layer type. Must be "vector" or "raster".'},

uvdat/core/rest/serializers.py

@@ -24,6 +24,8 @@
     VectorFeatureRowData,
     VectorFeatureTableData,
     VectorMapLayer,
+    FMVLayer,
+    FMVVectorFeature,
 )
 
 
@@ -187,6 +189,11 @@ class Meta:
         model = VectorMapLayer
         exclude = ['geojson_file']
 
+class FMVLayerSerializer(serializers.ModelSerializer, AbstractMapLayerSerializer):
+    class Meta:
+        model = FMVLayer
+        exclude = ['geojson_file']
+
 
 class NetCDFLayerSerializer(serializers.ModelSerializer):
     bounds = serializers.SerializerMethodField()

uvdat/urls.py

@@ -28,6 +28,7 @@
     UserViewSet,
     VectorFeatureTableDataViewSet,
     VectorMapLayerViewSet,
+    FMVLayerViewSet,
 )
 
 router = routers.SimpleRouter()
@@ -59,6 +60,7 @@
 router.register(r'layer-collections', LayerCollectionViewSet, basename='layer-collections')
 router.register(r'map-layers', MapLayerViewSet, basename='map-layers')
 router.register(r'netcdf', NetCDFDataView, basename='netcdf')
+router.register(r'fmv-layer', FMVLayerViewSet, basename='fmv-layer')
 router.register(r'processing-tasks', ProcessingTaskView, basename='processing-tasks')
 router.register(r'users', UserViewSet, basename='users')
 router.register(r'tasks', TasksAPIView, basename='tasks')