diff --git a/client/src/MapStore.ts b/client/src/MapStore.ts
index 90de437..f2e4a99 100644
--- a/client/src/MapStore.ts
+++ b/client/src/MapStore.ts
@@ -8,6 +8,7 @@ import {
   Context,
   Dataset,
   DisplayConfiguration,
+  FMVLayer,
   LayerCollection,
   NetCDFData,
   NetCDFImageWorking,
@@ -66,9 +67,9 @@ export default class MapStore {
   public static datasetsByContext = reactive<Record<number, Dataset[]>>({});
 
   // Layers
-  public static mapLayersByDataset = reactive<Record<number, (VectorMapLayer | RasterMapLayer | NetCDFData)[]>>({});
+  public static mapLayersByDataset = reactive<Record<number, (VectorMapLayer | RasterMapLayer | NetCDFData | FMVLayer)[]>>({});
 
-  public static selectedMapLayers = ref<(VectorMapLayer | RasterMapLayer | NetCDFLayer)[]>([]);
+  public static selectedMapLayers = ref<(VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer)[]>([]);
 
   public static visibleMapLayers: Ref<Set<string>> = ref(new Set());
 
@@ -88,6 +89,10 @@ export default class MapStore {
     () => this.selectedMapLayers.value.filter((layer) => layer.type === 'netcdf'),
   );
 
+  public static selectedFMVMapLayers: Ref<FMVLayer[]> = computed(
+    () => this.selectedMapLayers.value.filter((layer) => layer.type === 'fmv'),
+  );
+
   public static async loadCollections() {
     MapStore.availableCollections.value = await UVdatApi.getLayerCollections();
   }
@@ -121,8 +126,8 @@ export default class MapStore {
     if (initial && MapStore.displayConfiguration.value.default_displayed_layers.length) {
       const datasetIds = MapStore.displayConfiguration.value.default_displayed_layers.map((item) => item.dataset_id);
       const datasetIdLayers = await UVdatApi.getDatasetsLayers(datasetIds);
-      const layerByDataset: Record<number, (VectorMapLayer | RasterMapLayer | NetCDFData)[]> = {};
-      const toggleLayers: (VectorMapLayer | RasterMapLayer | NetCDFLayer)[] = [];
+      const layerByDataset: Record<number, (VectorMapLayer | RasterMapLayer | NetCDFData | FMVLayer)[]> = {};
+      const toggleLayers: (VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer)[] = [];
       const enabledLayers = MapStore.displayConfiguration.value.default_displayed_layers;
       datasetIdLayers.forEach((item) => {
         if (item.dataset_id !== undefined) {
@@ -180,7 +185,8 @@ export default class MapStore {
 
   public static vectorFeatureTableGraphVisible = ref(false);
 
-  public static vectorFeatureTableData: Ref<{ layerId: number, vectorFeatureId: number, defaultGraphs?: string[] } | null> = ref(null);
+  public static vectorFeatureTableData:
+  Ref<{ layerId: number, vectorFeatureId: number, defaultGraphs?: string[] } | null> = ref(null);
 
   public static setVectorFeatureTableData = (layerId: number, vectorFeatureId: number, defaultGraphs?: string[]) => {
     if (MapStore.mapLayerFeatureGraphsVisible.value) {
@@ -409,7 +415,8 @@ export default class MapStore {
         globalMax = Math.max(globalMax, max);
       }
     });
-    if ((MapStore.mapLayerFeatureGraphsVisible.value && MapStore.mapLayerFeatureGraphs.value.length) || MapStore.vectorFeatureTableGraphVisible.value) {
+    if ((MapStore.mapLayerFeatureGraphsVisible.value
+      && MapStore.mapLayerFeatureGraphs.value.length) || MapStore.vectorFeatureTableGraphVisible.value) {
       globalMin = Math.min(globalMin, MapStore.graphChartsMinMax.value.min);
       globalMax = Math.max(globalMax, MapStore.graphChartsMinMax.value.max);
       stepSize = Math.min(stepSize, MapStore.graphChartsMinMax.value.stepSize);
diff --git a/client/src/api/UVDATApi.ts b/client/src/api/UVDATApi.ts
index 7207ab0..23af766 100644
--- a/client/src/api/UVDATApi.ts
+++ b/client/src/api/UVDATApi.ts
@@ -10,6 +10,8 @@ import {
   Dataset,
   DerivedRegion,
   DisplayConfiguration,
+  FMVLayer,
+  FMVLayerData,
   FeatureGraphData,
   FeatureGraphs,
   FeatureGraphsRequest,
@@ -363,7 +365,7 @@ export default class UVdatApi {
   public static async getMapLayerCollectionList(
     layers: LayerCollectionLayer[],
     enabled? : boolean,
-  ): Promise<(VectorMapLayer | RasterMapLayer | NetCDFLayer)[]> {
+  ): Promise<(VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer)[]> {
     return (await UVdatApi.apiClient.post('/map-layers/', { layers }, { params: { enabled } })).data;
   }
 
@@ -375,6 +377,10 @@ export default class UVdatApi {
     return (await UVdatApi.apiClient.get(`/vectors/${mapLayerId}/bbox`)).data;
   }
 
+  public static async getFMVBbox(mapLayerId: number): Promise<Bounds> {
+    return (await UVdatApi.apiClient.get(`/fmv-layer/${mapLayerId}/bbox`)).data;
+  }
+
   public static async getMapLayersBoundingBox(
     rasterMapLayerIds: number[] = [],
     vectorMapLayerIds: number[] = [],
@@ -626,7 +632,7 @@ export default class UVdatApi {
   public static async getMapLayerList(
     layerIds: number[],
     layerTypes : AbstractMapLayer['type'][],
-  ): Promise<(VectorMapLayer | RasterMapLayer | NetCDFLayer)[]> {
+  ): Promise<(VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer)[]> {
     const params = new URLSearchParams();
 
     layerIds.forEach((id) => params.append('mapLayerIds', id.toString()));
@@ -663,4 +669,8 @@ export default class UVdatApi {
     const response = await UVdatApi.apiClient.patch('display-configuration/', config);
     return response.data;
   }
+
+  public static async getFMVLayerData(layerId: number): Promise<FMVLayerData> {
+    return (await UVdatApi.apiClient.get(`/fmv-layer/${layerId}/`)).data;
+  }
 }
diff --git a/client/src/components/DataSelection/DatasetItem.vue b/client/src/components/DataSelection/DatasetItem.vue
index 14a3f39..0e9ce7b 100644
--- a/client/src/components/DataSelection/DatasetItem.vue
+++ b/client/src/components/DataSelection/DatasetItem.vue
@@ -5,7 +5,9 @@ import {
   onUnmounted,
   ref,
 } from 'vue';
-import { NetCDFData, RasterMapLayer, VectorMapLayer } from '../../types';
+import {
+  FMVLayer, NetCDFData, RasterMapLayer, VectorMapLayer,
+} from '../../types';
 import { toggleLayerSelection } from '../../map/mapLayers';
 import MapStore from '../../MapStore';
 import NetCDFDataConfigurator from './NetCDFDataConfigurator.vue';
@@ -16,7 +18,7 @@ export default defineComponent({
   },
   props: {
     layer: {
-      type: Object as PropType<RasterMapLayer | VectorMapLayer | NetCDFData>,
+      type: Object as PropType<RasterMapLayer | VectorMapLayer | NetCDFData | FMVLayer>,
       required: true,
     },
   },
@@ -71,7 +73,7 @@ export default defineComponent({
 
 <template>
   <v-checkbox
-    v-if="layer.type === 'raster' || layer.type === 'vector'"
+    v-if="layer.type === 'raster' || layer.type === 'vector' || layer.type === 'fmv'"
     :model-value="!!selectedLayers.find((item) => (item.id === layer.id))"
     class="layer-checkbox"
     density="compact"
diff --git a/client/src/components/DataSelection/UploadFile.vue b/client/src/components/DataSelection/UploadFile.vue
index dc4a469..d352ae7 100644
--- a/client/src/components/DataSelection/UploadFile.vue
+++ b/client/src/components/DataSelection/UploadFile.vue
@@ -13,7 +13,9 @@ export default defineComponent({
     const uploadProgress = ref<number>(0);
     const uploadFile = ref<File | null>(null);
     const uploadError = ref<unknown>();
-    const acceptTypes = ref('.geojson, .json, .tif, .tiff, .zip, .gpkg, .nc');
+    const acceptTypes = ref(
+      '.geojson, .json, .tif, .tiff, .zip, .gpkg, .nc, .mpg, .mp4, .avi, .mov, .mkv, .webm, .jpg, .jpeg, .png, .gif',
+    );
 
     const fileInput = ref<HTMLInputElement | null>(null);
 
diff --git a/client/src/components/FMVLayerConfig.vue b/client/src/components/FMVLayerConfig.vue
new file mode 100644
index 0000000..7947fa5
--- /dev/null
+++ b/client/src/components/FMVLayerConfig.vue
@@ -0,0 +1,437 @@
+<script lang="ts">
+import {
+  PropType, computed, defineComponent, onMounted, onUnmounted, ref, watch,
+} from 'vue';
+import { FMVStore, FMVVectorTypes, getFMVStore } from '../map/fmvStore';
+import { FMVLayer } from '../types';
+import { updateFMVLayer, updateFMVVideoMapping } from '../map/mapFMVLayer';
+
+export default defineComponent({
+  props: {
+    layer: {
+      type: Object as PropType<FMVLayer>,
+      required: true,
+    },
+  },
+  setup(props) {
+    const fmvStore = ref<FMVStore | null>(null);
+    const loaded = ref(false);
+    const totalFrames = ref(0);
+    const allProperties = ['flight_path', 'ground_frame', 'ground_union', 'video'];
+    watch(() => fmvStore.value?.videoFrame, (newFrame) => {
+      if (newFrame && fmvStore.value) {
+        fmvStore.value.frameId = newFrame;
+        updateFMVVideoMapping(props.layer);
+      }
+    });
+    const frameId = computed<number>({
+      get: () => fmvStore.value?.frameId ?? 0,
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.frameId = val;
+          updateFMVLayer(props.layer);
+          updateFMVVideoMapping(props.layer);
+        }
+      },
+    });
+
+    const playingWhileDraggin = ref(false);
+
+    const startDraggingFrameSlider = () => {
+      if (fmvStore.value) {
+        playingWhileDraggin.value = fmvStore.value.videoState === 'playing';
+        if (playingWhileDraggin.value) {
+          fmvStore.value.setVideoState('pause');
+        }
+      }
+    };
+
+    const stopDraggingFrameSlider = () => {
+      if (playingWhileDraggin.value) {
+        playingWhileDraggin.value = false;
+        if (fmvStore.value) {
+          fmvStore.value.setVideoState('playing');
+        }
+      }
+    };
+
+    const lockZoom = computed({
+      get: () => fmvStore.value?.lockZoom ?? false,
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.lockZoom = val;
+        }
+      },
+    });
+
+    const zoomBounds = computed({
+      get: () => fmvStore.value?.zoomBounds ?? 1.5,
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.zoomBounds = val;
+        }
+      },
+    });
+
+    const opacity = computed({
+      get: () => fmvStore.value?.opacity ?? 0,
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.opacity = val;
+          updateFMVLayer(props.layer);
+        }
+      },
+    });
+
+    const visibleProperties = computed<(FMVVectorTypes | 'video')[]>({
+      get: () => fmvStore.value?.visibleProperties ?? [],
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.visibleProperties = val;
+          updateFMVLayer(props.layer);
+        }
+      },
+    });
+
+    const filterFrameStatus = computed<boolean>({
+      get: () => fmvStore.value?.filterFrameStatus ?? false,
+      set: (val) => {
+        if (fmvStore.value) {
+          fmvStore.value.filterFrameStatus = val;
+          updateFMVLayer(props.layer);
+        }
+      },
+    });
+
+    onMounted(async () => {
+      fmvStore.value = await getFMVStore(props.layer.id);
+      if (fmvStore.value) {
+        totalFrames.value = fmvStore.value.videoData.totalFrames ?? 0;
+        loaded.value = true;
+      }
+    });
+
+    const isPlaying = computed(() => fmvStore.value?.videoState === 'playing');
+
+    function togglePlayback() {
+      if (fmvStore.value) {
+        const newState = fmvStore.value.videoState === 'playing' ? 'pause' : 'playing';
+        fmvStore.value.setVideoState(newState);
+      }
+    }
+
+    function seekOffset(offset: number) {
+      const store = fmvStore.value;
+      if (!store) return;
+      store.seekOffset(offset);
+      updateFMVVideoMapping(props.layer);
+    }
+
+    let keyHoldInterval: ReturnType<typeof setInterval> | null = null;
+    let keyHoldStartTime = 0;
+
+    function getFrameJump(): number {
+      const heldDuration = Date.now() - keyHoldStartTime;
+      const secondsHeld = heldDuration / 1000;
+
+      // Increase jump size linearly, maxing out at 100 frames after ~20s
+      return Math.min(100, Math.floor(1 + secondsHeld * 5));
+    }
+
+    function stopFrameJump() {
+      if (keyHoldInterval) {
+        clearInterval(keyHoldInterval);
+        keyHoldInterval = null;
+      }
+    }
+
+    function jumpFrame(direction: 'left' | 'right', jump: number = 1) {
+      if (!fmvStore.value) return;
+
+      const total = fmvStore.value.videoData.totalFrames;
+      let newFrameId = fmvStore.value.frameId + (direction === 'right' ? jump : -jump);
+
+      // Wrap around
+      if (newFrameId < 0) newFrameId = total - 1;
+      if (newFrameId >= total) newFrameId = 0;
+
+      fmvStore.value.frameId = newFrameId;
+      updateFMVLayer(props.layer);
+      updateFMVVideoMapping(props.layer);
+    }
+
+    function startFrameJump(direction: 'left' | 'right') {
+      if (!fmvStore.value) return;
+
+      keyHoldStartTime = Date.now();
+      stopFrameJump(); // In case it's already running
+
+      // Start the accelerating jump loop
+      keyHoldInterval = setInterval(() => {
+        const jump = getFrameJump();
+        jumpFrame(direction, jump);
+      }, 100); // Tune this for responsiveness
+    }
+
+    function handleKeydown(event: KeyboardEvent) {
+      if (!fmvStore.value) return;
+
+      switch (event.code) {
+        case 'Space':
+          event.preventDefault();
+          togglePlayback();
+          break;
+        case 'ArrowLeft':
+          event.stopPropagation();
+          event.preventDefault();
+          if (!keyHoldInterval) {
+            // Do one frame step immediately
+            jumpFrame('left', 1);
+            startFrameJump('left');
+          }
+          break;
+        case 'ArrowRight':
+          event.stopPropagation();
+          event.preventDefault();
+          if (!keyHoldInterval) {
+            // Do one frame step immediately
+            jumpFrame('right', 1);
+            startFrameJump('right');
+          }
+          break;
+        default:
+          break;
+      }
+    }
+
+    function handleKeyup(event: KeyboardEvent) {
+      if (event.code === 'ArrowLeft' || event.code === 'ArrowRight') {
+        stopFrameJump();
+      }
+    }
+
+    onMounted(() => {
+      window.addEventListener('keydown', handleKeydown);
+      window.addEventListener('keyup', handleKeyup);
+    });
+
+    onUnmounted(() => {
+      window.removeEventListener('keydown', handleKeydown);
+      window.removeEventListener('keyup', handleKeyup);
+      stopFrameJump();
+    });
+    const speedTicks = ref([0.25, 0.5, 0.75, 1.0, 2.0, 4.0, 8.0]);
+    const speed = ref(1);
+
+    const setSpeed = (newSpeed: number) => {
+      if (fmvStore.value) {
+        speed.value = newSpeed;
+        fmvStore.value.setPlaybackSpeed(newSpeed);
+      }
+    };
+    return {
+      frameId,
+      visibleProperties,
+      filterFrameStatus,
+      totalFrames,
+      allProperties,
+      loaded,
+      isPlaying,
+      togglePlayback,
+      seekOffset,
+      opacity,
+      lockZoom,
+      zoomBounds,
+      speedTicks,
+      speed,
+      setSpeed,
+      startDraggingFrameSlider,
+      stopDraggingFrameSlider,
+    };
+  },
+});
+</script>
+
+<template>
+  <v-card-title>FMV Layer Controls</v-card-title>
+  <v-card-text v-if="loaded">
+    <v-row dense align="center" class="icon-row mb-2">
+      <v-col class="d-flex align-center gap-2">
+        <v-menu>
+          <template #activator="{ props }">
+            <v-badge
+              :value="speed !== 1.0"
+              color="#0277bd88"
+              :content="`${speed}X`"
+              overlap
+            >
+              <v-icon
+                x-small
+                v-bind="props"
+                @click="setSpeed(1)"
+              >
+                mdi-speedometer
+              </v-icon>
+            </v-badge>
+          </template>
+          <v-card style="overflow:hidden; width:90px;">
+            <v-slider
+              :model-value="speed"
+              min="0"
+              max="6"
+              step="1"
+              :ticks="speedTicks"
+              show-ticks="always"
+              :tick-size="4"
+              style="font-size:0.75em;"
+              direction="vertical"
+              @end="setSpeed($event)"
+            />
+          </v-card>
+        </v-menu>
+
+        <v-btn icon variant="plain" size="small" @click="seekOffset(-frameId)">
+          <v-icon>mdi-skip-backward</v-icon>
+        </v-btn>
+        <v-btn icon variant="plain" size="small" @click="seekOffset(-1)">
+          <v-icon>mdi-step-backward</v-icon>
+        </v-btn>
+        <v-btn icon variant="plain" size="small" @click="togglePlayback">
+          <v-icon>{{ isPlaying ? 'mdi-pause' : 'mdi-play' }}</v-icon>
+        </v-btn>
+        <v-btn icon variant="plain" size="small" @click="seekOffset(1)">
+          <v-icon>mdi-step-forward</v-icon>
+        </v-btn>
+        <v-btn icon variant="plain" size="small" @click="seekOffset(totalFrames - frameId)">
+          <v-icon>mdi-skip-forward</v-icon>
+        </v-btn>
+        <v-chip>{{ frameId }}</v-chip>
+        <v-btn
+          v-tooltip="'Filter Frames by frameId'"
+          icon
+          variant="plain"
+          size="small"
+          @click="filterFrameStatus = !filterFrameStatus"
+        >
+          <v-icon :color="filterFrameStatus ? 'primary' : ''">
+            mdi-filter
+          </v-icon>
+        </v-btn>
+      </v-col>
+    </v-row>
+    <v-row dense align="center">
+      <v-slider
+        v-model="frameId"
+        :min="0"
+        :max="totalFrames"
+        step="1"
+        thumb-label
+        :disabled="totalFrames === 0"
+        @start="startDraggingFrameSlider()"
+        @end="stopDraggingFrameSlider()"
+      />
+    </v-row>
+    <v-divider />
+
+    <v-row dense align="center">
+      <v-col cols="1">
+        <v-tooltip text="Opacity">
+          <template #activator="{ props }">
+            <v-icon
+              class="pl-3"
+              v-bind="props"
+            >
+              mdi-square-opacity
+            </v-icon>
+          </template>
+        </v-tooltip>
+      </v-col>
+      <v-col>
+        <v-slider
+          v-model="opacity"
+          density="compact"
+          hide-details
+          class="opacity-slider"
+          min="0"
+          max="1.0"
+        />
+      </v-col>
+    </v-row>
+    <v-row dense align="center">
+      <v-col cols="1">
+        <v-tooltip text="Lock Camera to Video, Bounds multiple Value">
+          <template #activator="{ props }">
+            <v-icon
+              class="px-3"
+              v-bind="props"
+              :color="lockZoom ? 'primary' : ''"
+              @click="lockZoom = !lockZoom"
+            >
+              {{ lockZoom ? 'mdi-lock-outline' : 'mdi-lock-open-outline' }}
+            </v-icon>
+          </template>
+        </v-tooltip>
+      </v-col>
+      <v-col>
+        <v-slider
+          v-model="zoomBounds"
+          density="compact"
+          hide-details
+          :min="1"
+          :max="5"
+          step="0.25"
+        />
+      </v-col>
+      <v-col cols="2">
+        {{ zoomBounds }}
+      </v-col>
+    </v-row>
+
+    <!-- Visible Properties Multi-select -->
+    <v-row dense align="center">
+      <v-col cols="3">
+        <span>Visible Properties:</span>
+      </v-col>
+      <v-col>
+        <v-select
+          v-model="visibleProperties"
+          :items="allProperties"
+          hide-details
+          label="Visible Properties"
+          multiple
+          chips
+          clearable
+        />
+      </v-col>
+    </v-row>
+  </v-card-text>
+  <v-card-text v-else>
+    Loading FMV Layer controls...
+  </v-card-text>
+</template>
+
+<style scoped>
+.tab {
+  border: 1px solid lightgray;
+}
+
+.tab:hover {
+  cursor: pointer;
+}
+
+.selected-tab {
+  background-color: lightgray;
+}
+
+.icon-center {
+  width: 35px;
+  height: 35px;
+  border: 1px solid lightgray;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.badge-text {
+  font-size: 0.75em;
+}
+</style>
diff --git a/client/src/components/LayerConfig.vue b/client/src/components/LayerConfig.vue
index abc7e14..cfb5c52 100644
--- a/client/src/components/LayerConfig.vue
+++ b/client/src/components/LayerConfig.vue
@@ -4,10 +4,12 @@ import {
 } from 'vue';
 import MapStore from '../MapStore';
 import {
+  FMVLayer,
   LayerRepresentation, NetCDFLayer, RasterMapLayer, VectorMapLayer,
 } from '../types';
 import RasterLayerConfig from './RasterLayerConfig.vue';
 import VectorLayerConfig from './VectorLayerConfig.vue';
+import FMVLayerConfig from './FMVLayerConfig.vue';
 import LayerRepresentationVue from './LayerRepresentation/LayerRepresentation.vue';
 import UVdatApi from '../api/UVDATApi';
 import { zoomToBounds } from '../map/mapLayers';
@@ -15,11 +17,11 @@ import NetCDFLayerConfig from './NetCDFLayerConfig.vue';
 
 export default defineComponent({
   components: {
-    RasterLayerConfig, VectorLayerConfig, LayerRepresentationVue, NetCDFLayerConfig,
+    RasterLayerConfig, VectorLayerConfig, LayerRepresentationVue, NetCDFLayerConfig, FMVLayerConfig,
   },
   props: {
     layer: {
-      type: Object as PropType<(VectorMapLayer | RasterMapLayer | NetCDFLayer)>,
+      type: Object as PropType<(VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer)>,
       required: true,
     },
   },
@@ -75,6 +77,9 @@ export default defineComponent({
       } else if (props.layer.type === 'vector') {
         const bounds = await UVdatApi.getVectorBbox(props.layer.id);
         zoomToBounds(bounds);
+      } else if (props.layer.type === 'fmv') {
+        const bounds = await UVdatApi.getFMVBbox(props.layer.id);
+        zoomToBounds(bounds);
       } else if (props.layer.type === 'netcdf') {
         const { bounds } = (props.layer as NetCDFLayer);
         zoomToBounds(bounds);
@@ -174,11 +179,12 @@ export default defineComponent({
       />
       <raster-layer-config v-if="proMode && layer.type === 'raster'" :layer="layer" />
       <vector-layer-config v-if="proMode && layer.type === 'vector'" :layer="layer" />
+      <FMVLayerConfig v-if="proMode && layer.type === 'fmv'" :layer="layer" />
       <NetCDFLayerConfig
         v-if="layer.type === 'netcdf'"
         :layer="layer"
       />
-      <v-card-actions v-if="proMode">
+      <v-card-actions v-if="proMode && layer.type !== 'fmv'">
         <v-row dense>
           <v-spacer />
           <v-tooltip :text="`Save: ${selectedLayerRep.name}`" location="top">
diff --git a/client/src/components/Map.vue b/client/src/components/Map.vue
index aef7563..4d9af25 100644
--- a/client/src/components/Map.vue
+++ b/client/src/components/Map.vue
@@ -14,6 +14,7 @@ import { setInternalMap } from '../map/mapLayers';
 import TVA_GEOJSON_RAW from '../assets/tva.geojson?raw';
 import vectorMapStyles from '../assets/basic-map-styles.json';
 import oauthClient from '../plugins/Oauth';
+import { updateFMVFlightPathSelected } from '../map/mapFMVLayer';
 
 const TVA_GEOJSON = JSON.parse(TVA_GEOJSON_RAW) as GeoJSON.GeoJSON;
 const OSM_VECTOR_ID = 'osm-vector';
@@ -231,6 +232,7 @@ export default defineComponent({
       () => {
         if (map.value) {
           updateSelected(map.value);
+          updateFMVFlightPathSelected(map.value);
         }
       },
       { deep: true },
diff --git a/client/src/map/fmvStore.ts b/client/src/map/fmvStore.ts
new file mode 100644
index 0000000..5a4c443
--- /dev/null
+++ b/client/src/map/fmvStore.ts
@@ -0,0 +1,241 @@
+/* eslint-disable no-console */
+/* eslint-disable no-underscore-dangle */
+import { Ref, reactive, toRefs } from 'vue';
+import { VideoSource } from 'maplibre-gl';
+import UVdatApi from '../api/UVDATApi';
+
+export type FMVVectorTypes = 'flight_path' | 'ground_frame' | 'ground_union';
+export interface FMVVideoState {
+  frameId: number;
+  videoFrame: number;
+  videoElement: HTMLVideoElement | null;
+  frameIdToBounds: Record<number, [[number, number], [number, number], [number, number], [number, number]]>
+  visibleProperties: (FMVVectorTypes | 'video')[];
+  filterFrameStatus: boolean;
+  videoState: 'pause' | 'playing';
+  opacity: number;
+  lockZoom: boolean;
+  zoomBounds: number;
+}
+const createFMVStore = () => {
+  const state: FMVVideoState = reactive({
+    frameId: 0,
+    videoFrame: 0,
+    videoElement: null as HTMLVideoElement | null,
+    frameIdToBounds: {} as Record<number, [[number, number], [number, number], [number, number], [number, number]]>,
+    filterFrameStatus: true,
+    visibleProperties: ['flight_path', 'video'] as (FMVVectorTypes | 'video')[],
+    videoState: 'pause',
+    opacity: 0.85,
+    lockZoom: false,
+    zoomBounds: 2,
+  });
+
+  let videoSource: VideoSource | null = null;
+
+  const videoData = reactive({
+    frameFps: 30,
+    frameWidth: 1920,
+    frameHeight: 1080,
+    totalFrames: 0,
+    videoUrl: '',
+  });
+
+  let animationFrameId: number | null = null;
+
+  const getFMVLayerInfo = async (mapLayerId: number) => {
+    const data = await UVdatApi.getFMVLayerData(mapLayerId);
+    if (data) {
+      Object.assign(videoData, {
+        frameFps: data.fmvFps || videoData.frameFps,
+        frameWidth: data.fmvFrameWidth || videoData.frameWidth,
+        frameHeight: data.fmvFrameHeight || videoData.frameHeight,
+        totalFrames: data.fmvFrameCount || videoData.totalFrames,
+        videoUrl: data.fmvVideoUrl || '',
+      });
+      state.frameIdToBounds = data.frameIdToBBox || {};
+    }
+  };
+
+  const getBoundsAtFrame = (id: number) => {
+    let corners = state.frameIdToBounds[id];
+    if (!corners) {
+      const sortedIds = Object.keys(state.frameIdToBounds)
+        .map(Number)
+        .sort((a, b) => a - b);
+      const nextId = sortedIds.find((existingId) => existingId > id);
+      if (nextId !== undefined) {
+        corners = state.frameIdToBounds[nextId];
+      }
+    }
+
+    if (!corners) {
+      console.error(`No bounds found for frameId ${id}`);
+    }
+
+    return corners as [[number, number], [number, number], [number, number], [number, number]];
+  };
+
+  const setVideoFrame = (frame: number) => {
+    if (frame >= 0 && frame < videoData.totalFrames) {
+      state.videoFrame = frame;
+      const video = state.videoElement;
+      if (video) {
+        video.currentTime = frame / videoData.frameFps;
+      }
+      videoSource?.seek(frame / videoData.frameFps);
+      state.frameId = frame;
+    } else {
+      console.error(`Frame ${frame} is out of bounds. Total frames: ${videoData.totalFrames}`);
+    }
+  };
+
+  const seekToFrame = (frame: number) => {
+    const setTime = frame / videoData.frameFps;
+    if (state.videoElement) {
+      state.videoFrame = frame;
+      videoSource?.seek(setTime);
+    }
+  };
+
+  const seekOffset = (offset: number) => {
+    const newFrame = Math.max(0, Math.min(videoData.totalFrames - 1, state.videoFrame + offset));
+    seekToFrame(newFrame);
+  };
+
+  const startAnimationLoop = () => {
+    const video = state.videoElement;
+    if (!video) return;
+
+    const updateFrame = () => {
+      if (!video.paused && !video.ended) {
+        const currentFrame = Math.floor(video.currentTime * videoData.frameFps);
+        state.videoFrame = currentFrame;
+        state.frameId = state.videoFrame;
+        animationFrameId = requestAnimationFrame(updateFrame);
+      } else {
+        if (animationFrameId) {
+          cancelAnimationFrame(animationFrameId);
+        }
+        animationFrameId = null;
+      }
+    };
+
+    updateFrame();
+  };
+
+  const setVideoSource = (baseSource: VideoSource) => {
+    if (state.videoElement && animationFrameId) {
+      cancelAnimationFrame(animationFrameId);
+    }
+    videoSource = baseSource;
+    state.videoElement = baseSource.getVideo();
+
+    if (state.videoElement) {
+      state.videoElement.autoplay = false;
+      state.videoElement.pause();
+
+      state.videoElement.onplay = () => {
+        startAnimationLoop();
+        state.videoState = 'playing';
+      };
+
+      state.videoElement.onpause = () => {
+        if (animationFrameId) {
+          cancelAnimationFrame(animationFrameId);
+          animationFrameId = null;
+          state.videoState = 'pause';
+        }
+      };
+    }
+  };
+
+  const setVideoState = (val: 'playing' | 'pause') => {
+    if (val === 'pause') {
+      state.videoElement?.pause();
+      state.videoState = val;
+    } else if (val === 'playing') {
+      if (state.videoElement) {
+        state.videoElement.currentTime = state.frameId / videoData.frameFps;
+      }
+      state.videoElement?.play();
+      state.videoState = 'pause';
+    }
+  };
+
+  const baseVectorTypes: FMVVectorTypes[] = ['flight_path', 'ground_frame', 'ground_union'];
+  const layerTypeVectorTypeMap: Record<FMVVectorTypes, 'circle' | 'fill'> = {
+    flight_path: 'circle',
+    ground_frame: 'fill',
+    ground_union: 'fill',
+  };
+
+  const setPlaybackSpeed = (speed: number) => {
+    if (state.videoElement) {
+      state.videoElement.playbackRate = speed;
+    }
+  };
+
+  return {
+    ...toRefs(state),
+    videoData,
+    baseVectorTypes,
+    layerTypeVectorTypeMap,
+    getBoundsAtFrame,
+    getFMVLayerInfo,
+    setVideoFrame,
+    setVideoSource,
+    seekOffset,
+    seekToFrame,
+    setVideoState,
+    setPlaybackSpeed,
+  };
+};
+
+export const fmvStores: Record<number, ReturnType<typeof createFMVStore>> = {};
+
+export const getFMVStore = async (mapLayerId: number) => {
+  if (!fmvStores[mapLayerId]) {
+    console.log(`Creating new FMV store for mapLayerId ${mapLayerId}`);
+    fmvStores[mapLayerId] = createFMVStore();
+    await fmvStores[mapLayerId].getFMVLayerInfo(mapLayerId).catch((error) => {
+      console.error(`Error fetching FMV layer data for mapLayerId ${mapLayerId}:`, error);
+    });
+  }
+  return fmvStores[mapLayerId];
+};
+
+export interface FMVStore {
+  frameId: Ref<number>;
+  videoFrame: Ref<number>;
+  videoElement: Ref<HTMLVideoElement | null>;
+  frameIdToBounds: Ref<Record<number, [[number, number], [number, number], [number, number], [number, number]]>>;
+  visibleProperties: Ref<(FMVVectorTypes | 'video')[]>;
+  filterFrameStatus: Ref<boolean>;
+  videoState: Ref<'pause' | 'playing'>;
+  opacity: Ref<number>;
+  lockZoom: Ref<boolean>;
+  zoomBounds: Ref<number>;
+
+  videoData: {
+    frameFps: number;
+    frameWidth: number;
+    frameHeight: number;
+    totalFrames: number;
+    videoUrl: string;
+  };
+
+  baseVectorTypes: FMVVectorTypes[];
+  layerTypeVectorTypeMap: Record<FMVVectorTypes, 'circle' | 'fill'>;
+
+  setVideoSource: (baseSource: VideoSource) => void;
+  setVideoFrame: (frame: number) => void;
+  setPlaybackSpeed: (speed: number) => void;
+  seekOffset: (offset: number) => void;
+  seekToFrame: (offset: number) => void;
+  getFMVLayerInfo: (id: number) => Promise<void>;
+  setVideoState: (val: 'playing' | 'pause') => void;
+  getBoundsAtFrame: (
+    id: number
+  ) => [[number, number], [number, number], [number, number], [number, number]];
+}
diff --git a/client/src/map/mapColors.ts b/client/src/map/mapColors.ts
index 0cc4db1..2857b98 100644
--- a/client/src/map/mapColors.ts
+++ b/client/src/map/mapColors.ts
@@ -228,4 +228,4 @@ const calculateColors = (map: maplibregl.Map, layer: VectorMapLayer) => {
   }
 };
 
-export { calculateColors, colorGenerator };
+export { calculateColors, colorGenerator, chainSelected };
diff --git a/client/src/map/mapFMVLayer.ts b/client/src/map/mapFMVLayer.ts
new file mode 100644
index 0000000..b4c3d97
--- /dev/null
+++ b/client/src/map/mapFMVLayer.ts
@@ -0,0 +1,478 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Ref, ref } from 'vue';
+import {
+  DataDrivenPropertyValueSpecification,
+  FilterSpecification,
+  VideoSource,
+} from 'maplibre-gl';
+import { difference, union } from 'lodash';
+import { AnnotationTypes, FMVLayer } from '../types';
+import MapStore from '../MapStore';
+import { getLayerDefaultFilter } from './mapFilters';
+import { subLayerMapping } from './mapHeatmap';
+import { FMVStore, getFMVStore } from './fmvStore';
+import { chainSelected } from './mapColors';
+
+const addedLayers: Ref<FMVLayer[]> = ref([]);
+const defaultAnnotationColor = 'black';
+const internalMap: Ref<maplibregl.Map | null> = ref(null);
+
+const fmvStoreMap : Record<number, FMVStore> = {};
+
+const setLayerFilter = (map: maplibregl.Map, layerId: string, filter: FilterSpecification | null) => {
+  if (map.getLayer(layerId)) {
+    map.setFilter(layerId, filter);
+  }
+};
+
+const getSelected = () => {
+  const result = [];
+  result.push('case');
+  result.push(['in', ['get', 'vectorfeatureid'], ['literal', MapStore.selectedIds.value]]);
+  result.push('cyan');
+  result.push(['has', 'colors']);
+  result.push([
+    'let',
+    'firstColor',
+    ['slice', ['get', 'colors'], 0, 7], // assuming each color is in the format '#RRGGBB'
+    ['to-color', ['var', 'firstColor']],
+  ]);
+
+  // Check if the 'color' field exists and match specific values
+  result.push(['has', 'color']);
+  result.push([
+    'match',
+    ['get', 'color'],
+    'light blue',
+    '#ADD8E6',
+    'dark blue',
+    '#00008B',
+    // add other color mappings here
+    ['get', 'color'], // if the color is already in a valid format
+  ]);
+  result.push(defaultAnnotationColor);
+  return result as DataDrivenPropertyValueSpecification<string>;
+};
+
+const getLineWidth = () => {
+  const result = [];
+  result.push('interpolate');
+  result.push(['linear']);
+  result.push(['zoom']);
+  result.push(5);
+  result.push(10);
+  result.push(7);
+  result.push(3);
+  result.push(10);
+  result.push(1);
+  result.push(14);
+  result.push(1);
+
+  return result as DataDrivenPropertyValueSpecification<number>;
+};
+
+const getFillOpacity = () => {
+  const result = 0.8;
+  return result as DataDrivenPropertyValueSpecification<number>;
+};
+
+const getCircleRadius = () => {
+  const result = [];
+  result.push('interpolate');
+  result.push(['linear']);
+  result.push(['zoom']);
+  result.push(5);
+  result.push(10);
+  result.push(7);
+  result.push(7);
+  result.push(10);
+  result.push(7);
+  result.push(14);
+  result.push(3);
+
+  return result as DataDrivenPropertyValueSpecification<number>;
+};
+
+// As selectedIds change we modify how they are drawn
+// TODO:  UPDATE SELECTED ID COLORS
+const updateFMVFlightPathSelected = (map: maplibregl.Map) => {
+  MapStore.selectedFMVMapLayers.value.forEach((layer) => {
+    const layerName = `FMVLayer_${layer.id}_circle`;
+    const colorFilter = chainSelected([], '#00FFFF', 'gray');
+    if (internalMap.value) {
+      internalMap.value.setPaintProperty(layerName, 'circle-color', colorFilter);
+    }
+  });
+};
+
+const baseVectorSource = new URL(
+  (import.meta.env.VUE_APP_API_ROOT as string || 'http://localhost:8000/api/v1'),
+  window.location.origin,
+);
+
+const setFMVInternalMap = (map: Ref<maplibregl.Map>) => {
+  internalMap.value = map.value;
+};
+
+const toggleVisibility = (map: maplibregl.Map, layer_type: AnnotationTypes, visible: boolean) => {
+  MapStore.selectedFMVMapLayers.value.forEach((layer) => {
+    const layerMap = {
+      circle: `FMVLayer_${layer.id}_circle`,
+      line: `FMVLayer_${layer.id}_line`,
+      fill: `FMVLayer_${layer.id}_fill`,
+      'fill-extrusion': `FMVLayer_${layer.id}_fill-extrusion`,
+      text: `FMVLayer_${layer.id}_text`,
+    };
+    const layerName = layerMap[layer_type];
+    if (map.getLayer(layerName)) {
+      map.setLayoutProperty(layerName, 'visibility', visible ? 'visible' : 'none');
+    }
+  });
+};
+const setLayerProperty = (
+  map: maplibregl.Map,
+  layerId: number,
+  layer_type: AnnotationTypes,
+  property: string,
+  val: string | number,
+  val2?: string | number,
+) => {
+  const layerMap = {
+    circle: `FMVLayer_${layerId}_circle`,
+    line: `FMVLayer_${layerId}_line`,
+    fill: `FMVLayer_${layerId}_fill`,
+    'fill-extrusion': `FMVLayer_${layerId}_fill-extrusion`,
+    text: `FMVLayer_${layerId}_text`,
+    heatmap: `FMVLayer_${layerId}_heatmap`,
+  };
+  const layerName = layerMap[layer_type];
+  if (map.getLayer(layerName)) {
+    if (property === 'zoom') map.setLayerZoomRange(layerName, val as number, (val2 as number) || 24);
+  }
+};
+
+const toggleFMVMapLayers = async (map: maplibregl.Map) => {
+  const addLayers: FMVLayer[] = [];
+  const removeLayers: FMVLayer[] = [];
+  MapStore.selectedFMVMapLayers.value.forEach((layer) => {
+    if (MapStore.visibleMapLayers.value.has(`${layer.type}_${layer.id}`)) {
+      addLayers.push(layer as FMVLayer);
+    }
+  });
+  const layerTypes: AnnotationTypes[] = ['fill', 'fill-extrusion', 'circle', 'line', 'text', 'heatmap'];
+  // Secondary pass to remove anything in Added that is not found in the system.
+  addedLayers.value.forEach((item) => {
+    if (
+      !addLayers.includes(item)
+      && map.getSource(`FMVVectorTile_${item.id}`)
+      && (
+        !MapStore.selectedFMVMapLayers.value.includes(item)
+        || !MapStore.visibleMapLayers.value.has(`${item.type}_${item.id}`)
+      )
+    ) {
+      removeLayers.push(item);
+    }
+  });
+  removeLayers.forEach((layer) => {
+    layerTypes.forEach((layerType) => {
+      if (map.getLayer(`FMVLayer_${layer.id}_${layerType}`)) {
+        map.removeLayer(`FMVLayer_${layer.id}_${layerType}`);
+      }
+    });
+    map.removeLayer(`FMVLayer_${layer.id}_video`);
+    map.removeSource(`FMVVectorTile_${layer.id}`);
+    map.removeSource(`FMVVideoSource_${layer.id}`);
+  });
+  // Now we add the sources that are included
+  const stores = await Promise.all(addLayers.map((layer) => getFMVStore(layer.id)));
+  addLayers.forEach((layer, idx) => {
+    const fmvStore = stores[idx];
+    fmvStoreMap[layer.id] = fmvStore;
+    let skipVector = false;
+    if (map.getSource(`FMVVectorTile_${layer.id}`)) {
+      skipVector = true;
+    }
+    if (!skipVector) {
+      map.addSource(`FMVVectorTile_${layer.id}`, {
+        tiles: [`${baseVectorSource}/fmv-layer/${layer.id}/tiles/{z}/{x}/{y}/`],
+        type: 'vector',
+      });
+      map.addLayer({
+        id: `FMVLayer_${layer.id}_circle`,
+        type: 'circle',
+        source: `FMVVectorTile_${layer.id}`,
+        'source-layer': 'default',
+        paint: {
+          'circle-color': getSelected(),
+          'circle-radius': getCircleRadius(),
+          'circle-opacity': 0.5,
+          'circle-stroke-width': 1,
+          'circle-stroke-color': getSelected(),
+        },
+      });
+      map.addLayer({
+        id: `FMVLayer_${layer.id}_line`,
+        type: 'line',
+        source: `FMVVectorTile_${layer.id}`,
+        'source-layer': 'default',
+        filter: getLayerDefaultFilter('line'),
+        layout: {
+          'line-join': 'round',
+          'line-cap': 'round',
+        },
+        paint: {
+          'line-width': getLineWidth(),
+        },
+      });
+      map.addLayer({
+        id: `FMVLayer_${layer.id}_fill`,
+        type: 'fill',
+        source: `FMVVectorTile_${layer.id}`,
+        'source-layer': 'default',
+        filter: getLayerDefaultFilter('fill'),
+        paint: {
+        // "fill-color": getAnnotationColor(),
+          'fill-color': 'blue',
+          'fill-opacity': getFillOpacity(),
+        },
+      });
+      map.addLayer({
+        id: `FMVLayer_${layer.id}_text`,
+        type: 'symbol',
+        source: `FMVVectorTile_${layer.id}`,
+        'source-layer': 'default',
+        layout: {
+          'text-anchor': 'center',
+          'text-font': ['Roboto Regular'],
+          'text-max-width': 5,
+          'text-size': 12,
+          'text-allow-overlap': true,
+        },
+        paint: {
+          'text-color': 'black',
+        },
+      });
+    }
+
+    const coordinates = fmvStore.getBoundsAtFrame(0);
+    map.addSource(`FMVVideoSource_${layer.id}`, {
+      type: 'video',
+      urls: [fmvStore.videoData.videoUrl],
+      coordinates,
+    });
+    map.addLayer({
+      id: `FMVLayer_${layer.id}_video`,
+      type: 'raster',
+      source: `FMVVideoSource_${layer.id}`,
+      paint: {
+        'raster-opacity': 1,
+        'raster-fade-duration': 0,
+      },
+    });
+    map.on('sourcedata', function handleVideoSourceLoad(e) {
+      if (
+        e.sourceId === `FMVVideoSource_${layer.id}`
+    && e.isSourceLoaded
+    && map.getSource(e.sourceId)
+      ) {
+        const videoSource = map.getSource(e.sourceId) as VideoSource;
+        const video = videoSource.getVideo();
+        fmvStore.setVideoSource(videoSource);
+
+        if (video) {
+          // Remove this listener after it's done
+          map.off('sourcedata', handleVideoSourceLoad);
+        }
+      }
+    });
+
+    delete subLayerMapping[`FMVLayer_${layer.id}_heatmap`];
+  });
+
+  addedLayers.value = addLayers;
+  MapStore.selectedFMVMapLayers.value.forEach((layer) => {
+    if (MapStore.visibleMapLayers.value.has(`${layer.type}_${layer.id}`)) {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      updateFMVLayer(layer);
+    }
+  });
+};
+
+const toggleLayerTypeVisibility = (
+  map: maplibregl.Map,
+  layerId: number,
+  layer_type: AnnotationTypes,
+  visible: boolean,
+) => {
+  const layerMap = {
+    circle: `FMVLayer_${layerId}_circle`,
+    line: `FMVLayer_${layerId}_line`,
+    fill: `FMVLayer_${layerId}_fill`,
+    'fill-extrusion': `FMVLayer_${layerId}_fill-extrusion`,
+    text: `FMVLayer_${layerId}_text`,
+    heatmap: `FMVLayer_${layerId}_heatmap`,
+  };
+  const layerName = layerMap[layer_type];
+  if (map.getLayer(layerName)) {
+    map.setLayoutProperty(layerName, 'visibility', visible ? 'visible' : 'none');
+    if (layer_type === 'heatmap' && !visible) {
+      delete subLayerMapping[layerName];
+    }
+  }
+};
+
+const updateFrameFilter = async (layer: FMVLayer) => {
+  if (!internalMap.value) return;
+
+  const fmvStore = fmvStoreMap[layer.id];
+  const baseFilters: FilterSpecification[] = [];
+
+  // Filter to specific frameId
+  if (fmvStore.filterFrameStatus.value) {
+    baseFilters.push(['any', ['==', ['get', 'fmvType'], 'ground_union'], ['==', ['get', 'frameId'], fmvStore.frameId.value]]);
+  }
+
+  // Filter to visible fmvTypes
+  if (fmvStore.visibleProperties.value.length > 0) {
+    baseFilters.push([
+      'in',
+      ['get', 'fmvType'],
+      ['literal', fmvStore.visibleProperties.value],
+    ]);
+  }
+
+  const layerTypes: AnnotationTypes[] = [
+    'fill',
+    'fill-extrusion',
+    'circle',
+    'line',
+    'text',
+    'heatmap',
+  ];
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const layerType of layerTypes) {
+    const layerName = `FMVLayer_${layer.id}_${layerType}`;
+    const filters = [...baseFilters];
+
+    // If it's a line layer, restrict geometry to LineString
+    if (layerType === 'circle') {
+      filters.push(['==', ['geometry-type'], 'Point']);
+    }
+
+    const finalFilter: FilterSpecification = filters.length === 1 ? filters[0] : ['all', ...filters];
+
+    setLayerFilter(internalMap.value, layerName, finalFilter);
+  }
+};
+
+type LatLon = [number, number]; // [longitude, latitude]
+type Bounds = [LatLon, LatLon, LatLon, LatLon];
+
+function boundsToBBoxWithMultiplier(
+  bounds: [[number, number], [number, number], [number, number], [number, number]],
+  sizeMultiplier: number = 1,
+): [number, number, number, number] {
+  // Extract all lats and lons
+  const lons = bounds.map(([lon, _]) => lon);
+  const lats = bounds.map(([_, lat]) => lat);
+
+  const minLon = Math.min(...lons);
+  const maxLon = Math.max(...lons);
+  const minLat = Math.min(...lats);
+  const maxLat = Math.max(...lats);
+
+  const centerLon = (minLon + maxLon) / 2;
+  const centerLat = (minLat + maxLat) / 2;
+
+  const halfWidth = ((maxLon - minLon) / 2) * sizeMultiplier;
+  const halfHeight = ((maxLat - minLat) / 2) * sizeMultiplier;
+
+  return [
+    centerLon - halfWidth, // minLon
+    centerLat - halfHeight, // minLat
+    centerLon + halfWidth, // maxLon
+    centerLat + halfHeight, // maxLat
+  ];
+}
+
+const updateFMVVideoMapping = (layer: FMVLayer) => {
+  if (!internalMap.value) return;
+  const fmvStore = fmvStoreMap[layer.id];
+  if (fmvStore && fmvStore.videoData) {
+    const coordinates = fmvStore.getBoundsAtFrame(fmvStore.frameId.value);
+    const source = internalMap.value.getSource(`FMVVideoSource_${layer.id}`);
+    if (source) {
+      (source as maplibregl.VideoSource).setCoordinates(coordinates);
+    }
+    if (fmvStore.lockZoom.value) {
+      const bounds = boundsToBBoxWithMultiplier(coordinates, fmvStore.zoomBounds.value);
+      internalMap.value.fitBounds(bounds, { linear: false, maxDuration: 0, animate: false });
+    }
+  }
+};
+
+const updateFMVLayer = (layer: FMVLayer) => {
+  const layerTypes: AnnotationTypes[] = ['fill', 'fill-extrusion', 'circle', 'line', 'text', 'heatmap'];
+  if (!internalMap.value) {
+    return;
+  }
+  layerTypes.forEach((layerType) => {
+    if (layerType === 'line') {
+      setLayerFilter(
+        internalMap.value as maplibregl.Map,
+        `FMVLayer_${layer.id}_circle`,
+        ['==', ['geometry-type'], 'Point'] as FilterSpecification,
+      );
+    }
+  });
+  const fmvStore = fmvStoreMap[layer.id];
+  if (fmvStore && internalMap.value) {
+    const videoLayerName = `FMVLayer_${layer.id}_video`;
+    if (!fmvStore.visibleProperties.value.includes('video')) {
+      internalMap.value.setLayoutProperty(videoLayerName, 'visibility', 'none');
+    } else {
+      internalMap.value.setLayoutProperty(videoLayerName, 'visibility', 'visible');
+      internalMap.value.setPaintProperty(videoLayerName, 'raster-opacity', fmvStore.opacity.value);
+    }
+  }
+  updateFrameFilter(layer);
+};
+
+const centerAndZoom = (center: number[], zoom: number, flyTo = false) => {
+  if (internalMap.value !== null) {
+    if (!flyTo) {
+      internalMap.value.setCenter(center as [number, number]);
+      internalMap.value.setZoom(zoom);
+    } else {
+      internalMap.value.flyTo({
+        center: center as [number, number],
+        zoom,
+      });
+    }
+  }
+};
+
+const getVideoSource = (layerId: number): VideoSource | null => {
+  if (internalMap.value) {
+    const source = internalMap.value.getSource(`FMVVideoSource_${layerId}`);
+    if (source && source.type === 'video') {
+      return source as VideoSource;
+    }
+  }
+  return null;
+};
+
+export {
+  setFMVInternalMap,
+  toggleFMVMapLayers,
+  toggleVisibility,
+  toggleLayerTypeVisibility,
+  setLayerProperty,
+  updateFMVFlightPathSelected,
+  updateFMVLayer,
+  updateFrameFilter,
+  centerAndZoom,
+  updateFMVVideoMapping,
+  getVideoSource,
+};
diff --git a/client/src/map/mapLayers.ts b/client/src/map/mapLayers.ts
index 60d6036..c5069fc 100644
--- a/client/src/map/mapLayers.ts
+++ b/client/src/map/mapLayers.ts
@@ -2,11 +2,12 @@ import { Ref, ref } from 'vue';
 import { setRasterInternalMap, toggleRasterMapLayers, updateRasterLayer } from './mapRasterLayers';
 import { setVectorInternalMap, toggleVectorMapLayers, updateVectorLayer } from './mapVectorLayers';
 import {
-  AbstractMapLayer, AnnotationTypes, Bounds, NetCDFLayer, RasterMapLayer, VectorMapLayer,
+  AbstractMapLayer, AnnotationTypes, Bounds, FMVLayer, NetCDFLayer, RasterMapLayer, VectorMapLayer,
 } from '../types';
 import { setPopupEvents } from './mouseEvents';
 import MapStore from '../MapStore';
 import { setNetCDFInternalMap, toggleNetCDFMapLayers } from './mapNetCDFLayer';
+import { setFMVInternalMap, toggleFMVMapLayers } from './mapFMVLayer';
 
 const internalMap: Ref<maplibregl.Map | null> = ref(null);
 const setInternalMap = (map: Ref<maplibregl.Map>) => {
@@ -15,6 +16,7 @@ const setInternalMap = (map: Ref<maplibregl.Map>) => {
     setVectorInternalMap(map);
     setRasterInternalMap(map);
     setNetCDFInternalMap(map);
+    setFMVInternalMap(map);
   }
 };
 
@@ -24,7 +26,7 @@ const reorderMapLayers = () => {
   const layerTypes: AnnotationTypes[] = ['fill', 'fill-extrusion', 'circle', 'line', 'heatmap', 'text'];
   // Loop through each selected layer in the desired order
   MapStore.selectedMapLayers.value.forEach(
-    (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer) => {
+    (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer) => {
       // Get the base ID for the current layer
       const layerBaseId = layer.id;
 
@@ -37,6 +39,8 @@ const reorderMapLayers = () => {
         layerNames.push(`Layer_${layerBaseId}_raster`);
       } else if (layer.type === 'netcdf') {
         layerNames.push(`NetCDFLayer_${layerBaseId}`);
+      } else if (layer.type === 'fmv') {
+        layerNames.push(`FMVLayer_${layerBaseId}`);
       }
 
       layerNames.forEach((layerName) => {
@@ -53,6 +57,7 @@ const toggleMapLayers = () => {
     toggleVectorMapLayers(internalMap.value);
     toggleRasterMapLayers(internalMap.value);
     toggleNetCDFMapLayers(internalMap.value);
+    toggleFMVMapLayers(internalMap.value);
     reorderMapLayers();
   }
 };
@@ -89,7 +94,7 @@ const getStringBBox = () => {
   return '';
 };
 
-const toggleLayerVisibility = (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer, visibility: boolean) => {
+const toggleLayerVisibility = (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer, visibility: boolean) => {
   if (visibility) {
     MapStore.visibleMapLayers.value.add(`${layer.type}_${layer.id}`);
   } else {
@@ -98,7 +103,7 @@ const toggleLayerVisibility = (layer: VectorMapLayer | RasterMapLayer | NetCDFLa
   toggleMapLayers();
 };
 
-const toggleLayerSelection = (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer) => {
+const toggleLayerSelection = (layer: VectorMapLayer | RasterMapLayer | NetCDFLayer | FMVLayer) => {
   const foundIndex = MapStore.selectedMapLayers.value.findIndex((item) => (item.id === layer.id));
   if (foundIndex !== -1) {
     MapStore.selectedMapLayers.value.splice(foundIndex, 1);
diff --git a/client/src/map/mouseEvents.ts b/client/src/map/mouseEvents.ts
index 384410d..b531107 100644
--- a/client/src/map/mouseEvents.ts
+++ b/client/src/map/mouseEvents.ts
@@ -256,6 +256,24 @@ const setPopupEvents = (localMap: Map) => {
         click: clickFunc,
       });
     }
+    for (let i = 0; i < MapStore.selectedFMVMapLayers.value.length; i += 1) {
+      const layer = MapStore.selectedFMVMapLayers.value[i];
+      const { id } = layer;
+      const clickFunc = singleClick;
+      const FMVAnnotationType = ['circle'];
+      // Other layers select and hover is used based on config
+      FMVAnnotationType.forEach((annotationType) => {
+        localMap.on('click', `FMVLayer_${id}_${annotationType}`, clickFunc);
+      });
+      localMap.off('click', clickOutside);
+      localMap.on('click', clickOutside);
+      loadedFunctions.push({
+        id,
+        mouseenter,
+        mouseleave,
+        click: clickFunc,
+      });
+    }
   }
 };
 
diff --git a/client/src/types.ts b/client/src/types.ts
index 5c3f1eb..0078c74 100644
--- a/client/src/types.ts
+++ b/client/src/types.ts
@@ -333,7 +333,7 @@ export interface PropertyDisplay {
 export interface AbstractMapLayer {
   id: number;
   name: string;
-  type: 'vector' | 'raster' | 'netcdf';
+  type: 'vector' | 'raster' | 'netcdf' | 'fmv';
   file_item?: {
     id: number;
     name: string;
@@ -939,3 +939,20 @@ export interface AbstractMapLayerListItem {
   file_item: { id: number, name: string }[];
   processing_tasks?: null | ProcessingTask[]
 }
+
+export interface FMVLayer extends AbstractMapLayer {
+  type: 'fmv';
+}
+
+export interface FMVLayerData {
+  name: string;
+  bbox:[number, number, number, number]; // [xmin, ymin, xmax, ymax]
+  frameIdToBBox: Record<
+  number, [[number, number], [number, number], [number, number], [number, number]]
+  >; // Maps frame ID to bounding box [xmin, ymin, xmax, ymax]
+  fmvVideoUrl: string; // URL to the FMV video file
+  fmvFps: number; // Frames per second of the FMV video
+  fmvFrameCount: number; // Total number of frames in the FMV video
+  fmvFrameWidth: number; // Width of the FMV video frames
+  fmvFrameHeight: number; // Height of the FMV video frames
+}
diff --git a/dev/kwiver.Dockerfile b/dev/kwiver.Dockerfile
new file mode 100644
index 0000000..058bd7b
--- /dev/null
+++ b/dev/kwiver.Dockerfile
@@ -0,0 +1,52 @@
+# Start from the KWIVER base image
+FROM kitware/kwiver:latest
+
+# Install system packages needed for Python and the app
+RUN apt-get update && apt-get install --yes --no-install-recommends \
+    build-essential wget curl libssl-dev zlib1g-dev libbz2-dev \
+    libreadline-dev libsqlite3-dev libncurses5-dev libncursesw5-dev \
+    xz-utils tk-dev git libffi-dev liblzma-dev libpq-dev \
+    libvips-dev gcc libc6-dev gdal-bin libgdal-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python 3.10 manually if not available
+RUN wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tgz && \
+    tar -xf Python-3.10.13.tgz && \
+    cd Python-3.10.13 && \
+    ./configure --enable-optimizations && \
+    make -j"$(nproc)" && \
+    make altinstall && \
+    cd .. && rm -rf Python-3.10.13*
+
+RUN python3.10 --version
+
+# Install Python packages
+RUN python3.10 -m ensurepip && \
+    python3.10 -m pip install --upgrade pip
+
+# Install large-image
+RUN python3.10 -m pip install large-image[gdal,pil] large-image-converter --find-links https://girder.github.io/large_image_wheels
+
+# Copy your application code
+COPY ./setup.py /opt/uvdat-server/setup.py
+COPY ./manage.py /opt/uvdat-server/manage.py
+COPY ./uvdat /opt/uvdat-server/uvdat
+
+# Install uvdat in editable mode with dev dependencies
+RUN python3.10 -m pip install --editable /opt/uvdat-server[dev]
+
+# Copy ffmpeg from static builder
+RUN wget -O ffmpeg.tar.xz https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz
+RUN mkdir /tmp/ffextracted
+RUN tar -xvf ffmpeg.tar.xz -C /tmp/ffextracted --strip-components 1
+
+# Copy ffmpeg into final image
+RUN cp /tmp/ffextracted/ffmpeg /usr/local/bin/
+RUN cp  /tmp/ffextracted/ffprobe /usr/local/bin/
+
+# Setup environment
+
+
+# Set working directory
+WORKDIR /opt/uvdat-server
+
diff --git a/docker-compose.override.yml b/docker-compose.override.yml
index 0e09f3f..4faf98e 100644
--- a/docker-compose.override.yml
+++ b/docker-compose.override.yml
@@ -2,7 +2,8 @@ services:
   django:
     build:
       context: .
-      dockerfile: ./dev/Dockerfile
+      dockerfile: ./dev/kwiver.Dockerfile
+    entrypoint: ["python3.10"]
     command: [ "./manage.py", "runserver", "0.0.0.0:8000" ]
     # Log printing via Rich is enhanced by a TTY
     tty: true
@@ -15,12 +16,13 @@ services:
       - postgres
       - rabbitmq
       - minio
-    platform: linux/amd64
+    platform: 'linux/amd64'
 
   celery:
     build:
       context: .
-      dockerfile: ./dev/Dockerfile
+      dockerfile: ./dev/kwiver.Dockerfile
+    entrypoint: ["python3.10" , "-m"]
     command:
       [
         "celery",
@@ -50,5 +52,25 @@ services:
     command: 'serve -a 0.0.0.0:8000 -f ./mkdocs.dev.yml'
     ports:
       - 8003:8000
+
+
+  client:
+    image: node:20
+    working_dir: /app
+    command: >
+      sh -c "
+        npm install &&
+        # If node_modules is not writable by others, make it so the host can modify and delete them
+        [ \"\$(stat -c '%A' node_modules | cut -c9)\" != 'w' ] && chmod o+w node_modules;
+        # Always run the dev server
+        npm run dev
+      "
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./client:/app
+    env_file:
+      - ./dev/.env.docker-compose
+
 volumes:
   vector-workdir:
diff --git a/sample_data/fmv.json b/sample_data/fmv.json
new file mode 100644
index 0000000..a06182c
--- /dev/null
+++ b/sample_data/fmv.json
@@ -0,0 +1,46 @@
+[{
+    "type": "Context",
+    "name": "FMV",
+    "default_map_center": [
+        34.8019,
+        -86.1794
+    ],
+    "default_map_zoom": 6,
+    "datasets": [
+        {
+            "name": "FMV",
+            "description": "FMV Testing",
+            "category": "fmv",
+            "metadata": {},
+            "files": [
+                {
+                    "path": "./data/FMV/fmv.mpg",
+                    "url": "https://data.kitware.com/api/v1/file/604a5a532fa25629b931c673/download",
+                    "name": "FMV Test Video",
+                    "type": "fmv",
+                    "action": "replace",
+                    "metadata": {
+                        "name": "FMV Testing Layer"
+                    }
+                }
+            ]
+        },
+        {
+            "name": "FMV Large",
+            "description": "FMV Testing",
+            "category": "fmv",
+            "metadata": {},
+            "files": [
+                {
+                    "path": "./data/FMV/fmv_large.mpg",
+                    "url": "https://data.kitware.com/api/v1/file/604a547c2fa25629b93176d2/download",
+                    "name": "FMV Large Video",
+                    "type": "fmv",
+                    "metadata": {
+                        "name":"FMV Large Video Layer"
+                    }
+                }
+            ]
+        }
+    ]
+}]
\ No newline at end of file
diff --git a/scripts/fmv/kwiver-klv.py b/scripts/fmv/kwiver-klv.py
new file mode 100644
index 0000000..77ce116
--- /dev/null
+++ b/scripts/fmv/kwiver-klv.py
@@ -0,0 +1,186 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "click",
+#   "shapely",
+#   "pyproj",
+# ]
+# ///
+ 
+"""
+KWIVER Dump to JSON Converter
+Uses the kitware/kwiver docker file to run dump-klv to create
+a CSV file with the output data (CSV is chosen becase the json file is a bit obtuse).
+The CSV file is converted to a JSON file for easer processing and from there it creates 3 files:
+output_metadata.geojson - geojson file with the camera footprint plus the camera positioning indexed by frame number
+ground_frame_mapping.json - dictionary where the keys are video frames and the values are a bounding box representing the video location
+bbox_frame.geojson - A geojson file of all of the ground mapped bounding boxes where each has a property of the frame.
+
+Usage:
+    uv kwiver-klv.py path/to/video.mpg ./output
+"""
+
+import csv
+import json
+import subprocess
+from pathlib import Path
+import click
+from shapely.geometry import Point, Polygon, mapping
+from shapely.ops import unary_union
+import pyproj
+
+@click.command()
+@click.argument('video', type=click.Path(exists=True), required=True)
+@click.argument('output_dir', type=click.Path(), default='./output')
+def main(video, output_dir):
+    video_path = Path(video).resolve()
+    output_dir = Path(output_dir).resolve()
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    output_csv = output_dir / 'output.csv'
+    output_json = output_dir / 'output.json'
+    geojson_out = output_dir / 'output_metadata.geojson'
+    bbox_out = output_dir / 'ground_frame_mapping.json'
+    bbox_geojson_out = output_dir / 'bbox_frame.geojson'
+    click.echo(f'Processing video: {video_path}')
+    click.echo('Running KWIVER via Docker to extract metadata...')
+
+    output_csv_file = Path(video_path.parent / 'output.csv')
+    cmd = [
+        'docker', 'run', '--rm',
+        '-v', f'{video_path.parent}:/data',
+        'kitware/kwiver:latest',
+        'dump-klv', f'/data/{video_path.name}',
+        '-l', f'/data/output.csv',
+        '-e', 'csv'
+    ]
+
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        click.secho(f'Error running KWIVER: {e}', fg='red')
+        return
+
+    if not output_csv_file.exists():
+        click.secho('KWIVER did not generate the expected CSV output.', fg='red')
+        return
+
+    click.echo(f'KWIVER output saved to {output_csv}')
+
+    click.echo(f'Reading {output_csv_file} and converting to JSON...')
+    with open(output_csv_file, newline='') as csvfile:
+        reader = csv.DictReader(csvfile)
+        frames = [row for row in reader]
+
+    with open(output_json, 'w') as f:
+        json.dump(frames, f, indent=2)
+
+    click.secho(f'JSON output written to {output_json}', fg='green')
+
+    geojson_data = create_geojson_and_bbox(frames)
+    with open(geojson_out, 'w') as f:
+        json.dump(geojson_data, f, indent=2)
+    click.secho(f'GeoJSON data created with {len(geojson_data["features"])} features.', fg='green')
+    click.secho(f'GeoJSON written to {geojson_out}', fg='cyan')
+
+
+def create_geojson_and_bbox(
+    frames,
+):
+    geod = pyproj.Geod(ellps='WGS84')
+    features = []
+    polygons = []
+    frame_polygons = []
+    frame_to_bbox = {}
+    total = len(frames)
+
+    for frame in frames:
+        try:
+            frame_id = frame.get("Frame ID", None)
+            if frame_id is None:
+                continue
+
+            # Sensor location
+            sensor_lat = float(frame['Sensor Geodetic Latitude (EPSG:4326)'])
+            sensor_lon = float(frame['Sensor Geodetic Longitude (EPSG:4326)'])
+
+            # Frame center and bounding
+            center_lat = float(frame['Geodetic Frame Center Latitude (EPSG:4326)'])
+            center_lon = float(frame['Geodetic Frame Center Longitude (EPSG:4326)'])
+            target_width = float(frame['Target Width (meters)'])
+            image_width = float(frame['Image Width'])
+            image_height = float(frame['Image Height'])
+            platform_heading = float(frame['Platform Heading Angle (degrees)'])
+            sensor_heading = float(frame['Sensor Relative Azimuth Angle (degrees)'])
+            heading = platform_heading + sensor_heading
+            # Build a rectangular footprint centered at the center point, rotated by heading
+            # Compute height in meters based on aspect ratio
+            target_height = (image_height / image_width) * target_width
+
+            # Half dimensions
+            half_width = target_width / 2
+            half_height = target_height / 2
+
+            # Corner offsets (dx, dy) relative to center
+            corner_offsets = [(-half_width, half_height), (half_width, half_height),
+                            (half_width, -half_height), (-half_width, -half_height)]
+
+            corners = []
+            for dx, dy in corner_offsets:
+                distance = (dx**2 + dy**2) ** 0.5
+                angle = (heading + np.degrees(np.arctan2(dx, dy))) % 360
+                lon, lat, _ = geod.fwd(center_lon, center_lat, angle, distance)
+                corners.append((lon, lat))
+            corners.append(corners[0])  # Close polygon            polygon = Polygon(corners)
+            polygons.append(polygon)
+            frame_polygons.append((frame_id, polygon))
+            frame_to_bbox[frame_id] = corners
+
+            # Point feature at sensor location
+            point = Point(sensor_lon, sensor_lat)
+            properties = {"fmvType": "flight_path"}
+            properties["frameId"] = int(frame_id)
+            for key, value in frame.items():
+                properties[key] = value
+
+            feature = {
+                "type": "Feature",
+                "geometry": mapping(point),
+                "properties": properties,
+            }
+            features.append(feature)
+
+        except (KeyError, ValueError) as e:
+            print(f"Skipping frame due to error: {e}")
+            continue
+
+    # Add unioned polygon
+    if polygons:
+        merged = unary_union(polygons)
+        features.append(
+            {
+                "type": "Feature",
+                "geometry": mapping(merged),
+                "properties": {"fmvType": "ground_union"},
+            }
+        )
+
+    # Individual frame bbox polygons with styling
+    for idx, (frame_id, poly) in enumerate(frame_polygons):
+        feature = {
+            "type": "Feature",
+            "geometry": mapping(poly),
+            "properties": {
+                "frameId": int(frame_id),
+                "fmvType": "ground_frame",
+            },
+        }
+        features.append(feature)
+
+    geojson = {"type": "FeatureCollection", "features": features}
+
+    return geojson
+
+if __name__ == '__main__':
+    main()
diff --git a/tox.ini b/tox.ini
index 232bd10..f03ce39 100644
--- a/tox.ini
+++ b/tox.ini
@@ -48,11 +48,11 @@ passenv =
 extras =
     dev
 deps =
-    factory-boy
-    pytest
-    pytest-django
-    pytest-factoryboy
-    pytest-mock
+    pytest==7.4.4
+    pytest-django==4.8.0
+    pytest-factoryboy==2.5.1
+    pytest-mock==3.12.0
+    factory-boy==3.3.0
 commands =
     pip install large-image-converter --find-links https://girder.github.io/large_image_wheels
     pytest {posargs}
diff --git a/uvdat/core/admin.py b/uvdat/core/admin.py
index 9bea800..9bb2140 100644
--- a/uvdat/core/admin.py
+++ b/uvdat/core/admin.py
@@ -7,6 +7,8 @@
     DerivedRegion,
     DisplayConfiguration,
     FileItem,
+    FMVLayer,
+    FMVVectorFeature,
     LayerCollection,
     LayerRepresentation,
     NetCDFData,
@@ -73,6 +75,32 @@ def get_map_layer_index(self, obj):
         return obj.map_layer.index
 
 
+class FMVLayerAdmin(admin.ModelAdmin):
+    list_display = [
+        'id',
+        'name',
+        'dataset',
+        'get_dataset_name',
+        'index',
+        'geojson_file',
+        'fmv_video',
+        'bounds',
+    ]
+
+    def get_dataset_name(self, obj):
+        return obj.dataset.name
+
+
+class FMVVectorFeatureAdmin(admin.ModelAdmin):
+    list_display = ['id', 'get_dataset_name', 'get_map_layer_index', 'properties']
+
+    def get_dataset_name(self, obj):
+        return obj.map_layer.dataset.name
+
+    def get_map_layer_index(self, obj):
+        return obj.map_layer.index
+
+
 class SourceRegionAdmin(admin.ModelAdmin):
     list_display = ['id', 'name', 'get_dataset_name']
 
@@ -229,6 +257,8 @@ class DisplayConfigurationAdmin(admin.ModelAdmin):
 admin.site.register(RasterMapLayer, RasterMapLayerAdmin)
 admin.site.register(VectorMapLayer, VectorMapLayerAdmin)
 admin.site.register(VectorFeature, VectorFeatureAdmin)
+admin.site.register(FMVLayer, FMVLayerAdmin)
+admin.site.register(FMVVectorFeature, FMVVectorFeatureAdmin)
 admin.site.register(SourceRegion, SourceRegionAdmin)
 admin.site.register(DerivedRegion, DerivedRegionAdmin)
 admin.site.register(Network, NetworkAdmin)
diff --git a/uvdat/core/migrations/0005_fmvlayer_fmvvectorfeature.py b/uvdat/core/migrations/0005_fmvlayer_fmvvectorfeature.py
new file mode 100644
index 0000000..84ba282
--- /dev/null
+++ b/uvdat/core/migrations/0005_fmvlayer_fmvvectorfeature.py
@@ -0,0 +1,111 @@
+# Generated by Django 5.0.7 on 2025-06-09 12:26
+
+import django.contrib.gis.db.models.fields
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import s3_file_field.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0004_displayconfiguration'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='FMVLayer',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name='ID'
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('metadata', models.JSONField(blank=True, null=True)),
+                ('default_style', models.JSONField(blank=True, null=True)),
+                ('index', models.IntegerField(null=True)),
+                ('name', models.CharField(blank=True, max_length=255)),
+                (
+                    'bounds',
+                    django.contrib.gis.db.models.fields.PolygonField(
+                        blank=True, help_text='Bounds/Extents of the Layer', null=True, srid=4326
+                    ),
+                ),
+                ('fmv_source_video', s3_file_field.fields.S3FileField(null=True)),
+                ('fmv_video', s3_file_field.fields.S3FileField(null=True)),
+                ('geojson_file', s3_file_field.fields.S3FileField(null=True)),
+                (
+                    'fmv_fps',
+                    models.FloatField(
+                        blank=True, help_text='Frames per second of the FMV video.', null=True
+                    ),
+                ),
+                (
+                    'fmv_frame_count',
+                    models.IntegerField(
+                        blank=True, help_text='Total number of frames in the FMV video.', null=True
+                    ),
+                ),
+                (
+                    'fmv_video_duration',
+                    models.FloatField(
+                        blank=True, help_text='Duration of the FMV video in seconds.', null=True
+                    ),
+                ),
+                (
+                    'fmv_video_width',
+                    models.IntegerField(
+                        blank=True, help_text='Width of the FMV video in pixels.', null=True
+                    ),
+                ),
+                (
+                    'fmv_video_height',
+                    models.IntegerField(
+                        blank=True, help_text='Height of the FMV video in pixels.', null=True
+                    ),
+                ),
+                (
+                    'dataset',
+                    models.ForeignKey(
+                        null=True, on_delete=django.db.models.deletion.CASCADE, to='core.dataset'
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='FMVVectorFeature',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name='ID'
+                    ),
+                ),
+                ('geometry', django.contrib.gis.db.models.fields.GeometryField(srid=4326)),
+                ('properties', models.JSONField()),
+                (
+                    'map_layer',
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, to='core.fmvlayer'
+                    ),
+                ),
+            ],
+        ),
+    ]
diff --git a/uvdat/core/models/__init__.py b/uvdat/core/models/__init__.py
index b7d2f56..77997ea 100644
--- a/uvdat/core/models/__init__.py
+++ b/uvdat/core/models/__init__.py
@@ -5,7 +5,14 @@
 from .file_item import FileItem
 from .layer_collection import LayerCollection
 from .layer_representation import LayerRepresentation
-from .map_layers import AbstractMapLayer, RasterMapLayer, VectorFeature, VectorMapLayer
+from .map_layers import (
+    AbstractMapLayer,
+    FMVLayer,
+    FMVVectorFeature,
+    RasterMapLayer,
+    VectorFeature,
+    VectorMapLayer,
+)
 from .netcdf import NetCDFData, NetCDFImage, NetCDFLayer
 from .networks import Network, NetworkEdge, NetworkNode
 from .processing_task import ProcessingTask
@@ -37,4 +44,6 @@
     VectorFeatureTableData,
     VectorFeatureRowData,
     DisplayConfiguration,
+    FMVVectorFeature,
+    FMVLayer,
 ]
diff --git a/uvdat/core/models/dataset.py b/uvdat/core/models/dataset.py
index 8c8f481..103baec 100644
--- a/uvdat/core/models/dataset.py
+++ b/uvdat/core/models/dataset.py
@@ -49,5 +49,8 @@ def get_regions(self):
 
     def get_map_layers(self):
         return chain(
-            self.rastermaplayer_set.all(), self.vectormaplayer_set.all(), self.netcdfdata_set.all()
+            self.rastermaplayer_set.all(),
+            self.vectormaplayer_set.all(),
+            self.netcdfdata_set.all(),
+            self.fmvlayer_set.all(),
         )
diff --git a/uvdat/core/models/map_layers.py b/uvdat/core/models/map_layers.py
index f4093ed..2914118 100644
--- a/uvdat/core/models/map_layers.py
+++ b/uvdat/core/models/map_layers.py
@@ -39,7 +39,7 @@ def set_bounds(self):
                 self.bounds = Polygon.from_bbox(
                     (bbox['xmin'], bbox['ymin'], bbox['xmax'], bbox['ymax'])
                 )
-        elif isinstance(self, VectorMapLayer):
+        elif isinstance(self, (VectorMapLayer, FMVLayer)):
             geojson_data = self.read_geojson_data()
             if 'features' in geojson_data:
                 geometries = [shape(feature['geometry']) for feature in geojson_data['features']]
@@ -104,6 +104,85 @@ def read_geojson_data(self) -> dict:
         return json.load(self.geojson_file.open())
 
 
+class FMVLayer(AbstractMapLayer):
+    fmv_source_video = S3FileField(null=True)
+    fmv_video = S3FileField(null=True)
+    geojson_file = S3FileField(null=True)
+    fmv_fps = models.FloatField(
+        null=True, blank=True, help_text='Frames per second of the FMV video.'
+    )
+    fmv_frame_count = models.IntegerField(
+        null=True, blank=True, help_text='Total number of frames in the FMV video.'
+    )
+    fmv_video_duration = models.FloatField(
+        null=True, blank=True, help_text='Duration of the FMV video in seconds.'
+    )
+    fmv_video_width = models.IntegerField(
+        null=True, blank=True, help_text='Width of the FMV video in pixels.'
+    )
+    fmv_video_height = models.IntegerField(
+        null=True, blank=True, help_text='Height of the FMV video in pixels.'
+    )
+
+    def write_geojson_data(self, content: str | dict):
+        if isinstance(content, str):
+            data = content
+        elif isinstance(content, dict):
+            data = json.dumps(content)
+        else:
+            raise Exception(f'Invalid content type supplied: {type(content)}')
+
+        self.geojson_file.save('vectordata.geojson', ContentFile(data.encode()))
+
+    def read_geojson_data(self) -> dict:
+        """Read and load the data from geojson_file into a dict."""
+        return json.load(self.geojson_file.open())
+
+    def get_ground_frame_mapping(self) -> dict:
+        """Return a mapping from frameId -> 4-point polygon coordinates."""
+        result = {}
+        features = FMVVectorFeature.objects.filter(
+            map_layer=self,
+            properties__fmvType='ground_frame',
+        ).exclude(properties__frameId__isnull=True)
+
+        for feature in features:
+            frame_id = feature.properties.get('frameId')
+            geom = feature.geometry
+
+            if geom.geom_type == 'Polygon':
+                # 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':
+                # 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:
+                continue
+
+        return result
+
+
+@receiver(models.signals.pre_delete, sender=FMVLayer)
+def delete__fmvvectorcontent(sender, instance, **kwargs):
+    if instance.geojson_file:
+        instance.geojson_file.delete(save=False)
+
+
+class FMVVectorFeature(models.Model):
+    map_layer = models.ForeignKey(FMVLayer, on_delete=models.CASCADE)
+    geometry = geomodels.GeometryField()
+    properties = models.JSONField()
+
+
 @receiver(models.signals.pre_delete, sender=VectorMapLayer)
 def delete__vectorcontent(sender, instance, **kwargs):
     if instance.geojson_file:
diff --git a/uvdat/core/rest/__init__.py b/uvdat/core/rest/__init__.py
index 81a524e..8f3e48d 100644
--- a/uvdat/core/rest/__init__.py
+++ b/uvdat/core/rest/__init__.py
@@ -4,6 +4,7 @@
 from .display_configuration import DisplayConfigurationViewSet
 from .file_item import FileItemViewSet
 from .filter_metadata import MetadataFilterViewSet
+from .fmv import FMVLayerViewSet
 from .layer_collection import LayerCollectionViewSet
 from .layer_representation import LayerRepresentationViewSet
 from .map_layers import MapLayerViewSet, RasterMapLayerViewSet, VectorMapLayerViewSet
@@ -40,4 +41,5 @@
     TasksAPIView,
     MetadataFilterViewSet,
     DisplayConfigurationViewSet,
+    FMVLayerViewSet,
 ]
diff --git a/uvdat/core/rest/dataset.py b/uvdat/core/rest/dataset.py
index 32fbcef..364a004 100644
--- a/uvdat/core/rest/dataset.py
+++ b/uvdat/core/rest/dataset.py
@@ -9,6 +9,7 @@
 from uvdat.core.models import (
     Dataset,
     FileItem,
+    FMVLayer,
     NetCDFData,
     NetworkEdge,
     NetworkNode,
@@ -66,8 +67,12 @@ def map_layers(self, request, **kwargs):
             [layer for layer in map_layers if isinstance(layer, NetCDFData)], many=True
         ).data
 
+        fmv_layers = uvdat_serializers.FMVLayerSerializer(
+            [layer for layer in map_layers if isinstance(layer, FMVLayer)], many=True
+        ).data
+
         # Combine both serialized data
-        combined_layers = raster_layers + vector_layers + netcdf_data
+        combined_layers = raster_layers + vector_layers + netcdf_data + fmv_layers
 
         # Return response with combined data
         return Response(combined_layers, status=200)
@@ -93,8 +98,12 @@ def map_layers_from_datasets(self, request, **kwargs):
                 [layer for layer in map_layers if isinstance(layer, NetCDFData)], many=True
             ).data
 
+            fmv_layers = uvdat_serializers.FMVLayerSerializer(
+                [layer for layer in map_layers if isinstance(layer, FMVLayer)], many=True
+            ).data
+
             # Combine both serialized data
-            combined_layers = raster_layers + vector_layers + netcdf_data
+            combined_layers = raster_layers + vector_layers + netcdf_data + fmv_layers
             total_layers += combined_layers
 
         # Return response with combined data
diff --git a/uvdat/core/rest/file_item.py b/uvdat/core/rest/file_item.py
index ad36261..4f0f9ca 100644
--- a/uvdat/core/rest/file_item.py
+++ b/uvdat/core/rest/file_item.py
@@ -11,6 +11,18 @@
 from .permissions import DefaultPermission
 
 VALID_FILE_TYPES = {'geojson', 'json', 'tiff', 'tif', 'zip', 'gpkg', 'nc'}
+valid_video_format = (
+    'mp4',
+    'webm',
+    'avi',
+    'mov',
+    'wmv',
+    'mpg',
+    'mpeg',
+    'mp2',
+    'ogg',
+    'flv',
+)
 
 
 class FileItemViewSet(ModelViewSet):
@@ -41,11 +53,15 @@ def create(self, request, *args, **kwargs):
         _, extension = os.path.splitext(file_key)
         extension = extension.lower().strip('.')
 
-        if extension in VALID_FILE_TYPES:
+        if extension in VALID_FILE_TYPES or extension in valid_video_format:
             if extension == 'json':
                 file_type = 'geojson'
             elif extension == 'nc':
                 file_type = 'netcdf'
+            elif extension == 'nc':
+                file_type = 'netcdf'
+            elif extension in valid_video_format:
+                file_type = 'fmv'
             else:
                 file_type = extension
         else:
diff --git a/uvdat/core/rest/fmv.py b/uvdat/core/rest/fmv.py
new file mode 100644
index 0000000..7d6291d
--- /dev/null
+++ b/uvdat/core/rest/fmv.py
@@ -0,0 +1,130 @@
+from django.core.files.storage import default_storage
+from django.db import connection
+from django.http import HttpResponse, JsonResponse
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet
+
+from uvdat.core.models import FMVLayer
+from uvdat.core.rest.serializers import FMVLayerSerializer
+
+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 vectorfeatureid,
+        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(ModelViewSet):
+    queryset = FMVLayer.objects.select_related('dataset').all()
+    serializer_class = FMVLayerSerializer
+
+    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)
+
+        # Get bbox as [xmin, ymin, xmax, ymax]
+        bbox = list(layer.bounds.extent) if layer.bounds else None
+
+        data = {
+            'name': layer.name,
+            'fmvVideoUrl': presigned_url,
+            'fmvFps': layer.fmv_fps,
+            'fmvFrameCount': layer.fmv_frame_count,
+            'fmvFrameWidth': layer.fmv_video_width,
+            'fmvFrameHeight': layer.fmv_video_height,
+            'bbox': bbox,
+            'frameIdToBBox': layer.get_ground_frame_mapping(),
+        }
+        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,
+        )
+
+    @action(
+        detail=True,
+        methods=['get'],
+        url_path='bbox',
+        url_name='bbox',
+    )
+    def get_fmv_bbox(self, request, **kwargs):
+        fmv_map_layer = self.get_object()
+
+        if fmv_map_layer.bounds:
+            bounds = fmv_map_layer.bounds.extent
+            bbox_dict = {'xmin': bounds[0], 'ymin': bounds[1], 'xmax': bounds[2], 'ymax': bounds[3]}
+            return JsonResponse(bbox_dict)
+
+        data = fmv_map_layer.get_bbox()
+        return JsonResponse(data, status=200, safe=False)
diff --git a/uvdat/core/rest/map_layers.py b/uvdat/core/rest/map_layers.py
index d9a9eeb..aee4425 100644
--- a/uvdat/core/rest/map_layers.py
+++ b/uvdat/core/rest/map_layers.py
@@ -15,6 +15,8 @@
 from rest_framework.viewsets import GenericViewSet, ModelViewSet
 
 from uvdat.core.models import (
+    FMVLayer,
+    FMVVectorFeature,
     LayerRepresentation,
     NetCDFData,
     NetCDFLayer,
@@ -24,6 +26,7 @@
 )
 from uvdat.core.rest.serializers import (
     AbstractMapLayerSerializer,
+    FMVLayerSerializer,
     NetCDFLayerSerializer,
     RasterMapLayerSerializer,
     VectorMapLayerDetailSerializer,
@@ -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'], fmv_bboxes[0])
+                overall_bbox['ymin'] = min(overall_bbox['ymin'], fmv_bboxes[1])
+                overall_bbox['xmax'] = max(overall_bbox['xmax'], fmv_bboxes[2])
+                overall_bbox['ymax'] = max(overall_bbox['ymax'], fmv_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".'},
diff --git a/uvdat/core/rest/serializers.py b/uvdat/core/rest/serializers.py
index 7ba9f73..bdcc85b 100644
--- a/uvdat/core/rest/serializers.py
+++ b/uvdat/core/rest/serializers.py
@@ -10,6 +10,7 @@
     Dataset,
     DerivedRegion,
     FileItem,
+    FMVLayer,
     LayerCollection,
     LayerRepresentation,
     NetCDFData,
@@ -118,16 +119,20 @@ def get_name(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFDa
             return f'{obj.dataset.name} Layer {obj.index}'
         return None
 
-    def get_type(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+    def get_type(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData | FMVLayer):
         if isinstance(obj, VectorMapLayer):
             return 'vector'
         if isinstance(obj, RasterMapLayer):
             return 'raster'
         if isinstance(obj, NetCDFLayer) or isinstance(obj, NetCDFData):
             return 'netcdf'
+        if isinstance(obj, FMVLayer):
+            return 'fmv'
         return 'none'
 
-    def get_dataset_id(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+    def get_dataset_id(
+        self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData | FMVLayer
+    ):
         if isinstance(obj, NetCDFLayer):
             return obj.netcdf_data.dataset.id
         if isinstance(obj, NetCDFData):
@@ -136,7 +141,9 @@ def get_dataset_id(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | Ne
             return obj.dataset.id
         return None
 
-    def get_file_item(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData | NetCDFLayer):
+    def get_file_item(
+        self, obj: VectorMapLayer | RasterMapLayer | NetCDFData | NetCDFLayer | FMVLayer
+    ):
         if isinstance(obj, NetCDFLayer):
             for file_item in obj.netcdf_data.dataset.source_files.all():
                 if file_item.index == obj.netcdf_data.index:
@@ -188,6 +195,12 @@ class Meta:
         exclude = ['geojson_file']
 
 
+class FMVLayerSerializer(serializers.ModelSerializer, AbstractMapLayerSerializer):
+    class Meta:
+        model = FMVLayer
+        exclude = ['geojson_file', 'bounds', 'fmv_source_video', 'fmv_video']
+
+
 class NetCDFLayerSerializer(serializers.ModelSerializer):
     bounds = serializers.SerializerMethodField()
     type = serializers.SerializerMethodField()
diff --git a/uvdat/core/tasks/dataset.py b/uvdat/core/tasks/dataset.py
index d8e0c89..09910bf 100644
--- a/uvdat/core/tasks/dataset.py
+++ b/uvdat/core/tasks/dataset.py
@@ -8,6 +8,7 @@
 from uvdat.core.tasks.map_layers import save_vector_features
 
 from .csv_to_heatmap import process_file_item_to_heatmap
+from .fmv import create_fmv_layer
 from .map_layers import (
     create_raster_map_layer,
     create_vector_map_layer,
@@ -21,6 +22,20 @@
 logger = logging.getLogger(__name__)
 
 
+valid_video_format = (
+    'mp4',
+    'webm',
+    'avi',
+    'mov',
+    'wmv',
+    'mpg',
+    'mpeg',
+    'mp2',
+    'ogg',
+    'flv',
+)
+
+
 @shared_task
 def convert_dataset(
     dataset_id,
@@ -79,7 +94,8 @@ def convert_dataset(
                             vector_map_layer.pk, tabular_geojson, tabular_matcher
                         )
                 vector_map_layer.set_bounds()
-
+        elif file_name.endswith(valid_video_format):
+            create_fmv_layer(file_to_convert, style_options, file_name, file_metadata)
         elif file_name.endswith(('.tif', '.tiff')):
             # Handle Raster files
             raster_map_layer = create_raster_map_layer(
@@ -117,6 +133,7 @@ def process_file_item(self, file_item_id):
     raster_map_layers = []
     vector_map_layers = []
     netcdf_map_layers = []
+    fmv_map_layers = []
     processing_task.update(status=ProcessingTask.Status.RUNNING)
     try:
         if file_name.endswith('.gpkg'):
@@ -141,6 +158,9 @@ def process_file_item(self, file_item_id):
                 vector_map_layer.set_bounds()
                 vector_map_layers.append(vector_map_layer)
 
+        elif file_name.endswith(valid_video_format):
+            fmv_map_layer = create_fmv_layer(file_item, style_options, file_name, file_metadata)
+            fmv_map_layers.append(fmv_map_layer)
         elif file_name.endswith(('.tif', '.tiff')):
             # Handle Raster files
             raster_map_layer = create_raster_map_layer(
@@ -176,6 +196,7 @@ def process_file_item(self, file_item_id):
                     'raster_map_layers': [rml.id for rml in raster_map_layers],
                     'vector_map_layers': [vml.id for vml in vector_map_layers],
                     'net_cdf_map_layers': netcdf_map_layers,
+                    'fmv_map_layers': [fmv.id for fmv in fmv_map_layers],
                 }
             },
         )
diff --git a/uvdat/core/tasks/fmv.py b/uvdat/core/tasks/fmv.py
new file mode 100644
index 0000000..f984a0d
--- /dev/null
+++ b/uvdat/core/tasks/fmv.py
@@ -0,0 +1,266 @@
+import csv
+import json
+import logging
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+from django.contrib.gis.geos import GEOSGeometry
+from django.core.files.base import ContentFile
+import numpy as np
+import pyproj
+from shapely.geometry import Point, Polygon, mapping
+from shapely.ops import unary_union
+
+from uvdat.core.models import (
+    FMVLayer,
+    FMVVectorFeature,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def create_fmv_layer(file_item, style_options, file_name, metadata=None):
+    # First we grab the video file
+    with tempfile.TemporaryDirectory() as temp_dir:
+        video_ext = os.path.splitext(file_name)[1]
+        logger.info(f'file_name: {file_name} extension: {video_ext}')
+        layer_name = metadata.get('name', file_name)
+        raw_data_path = Path(temp_dir, f'video{video_ext}')
+        logger.info(f'RAW DATA PATH {raw_data_path}')
+        with open(raw_data_path, 'wb') as raw_data:
+            with file_item.file.open('rb') as raw_data_archive:
+                raw_data.write(raw_data_archive.read())
+        # Now lets see if the FMV file has FMV data
+        output_csv = Path(temp_dir, 'output.csv')
+        cmd = [
+            'bash',
+            '/entrypoint.sh',
+            'dump-klv',
+            str(raw_data_path),
+            '-l',
+            str(output_csv),
+            '-e',
+            'csv',
+        ]
+        # cmd = [
+        #     '/opt/kitware/kwiver/bin/kwiver',
+        #     'dump-klv', str(raw_data_path),
+        #     '-l', str(output_csv),
+        #     '-e', 'csv'
+        # ]
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            logger.error(f'Error running KWIVER: {e}')
+            return
+
+        if not output_csv.exists():
+            logger.error('KWIVER did not generate the expected CSV output.')
+            return
+
+        with open(output_csv, newline='') as csvfile:
+            reader = csv.DictReader(csvfile)
+            frames = [row for row in reader]
+        output_json = Path(temp_dir, 'output.json')
+        with open(output_json, 'w') as f:
+            json.dump(frames, f, indent=2)
+
+        logger.info(f'JSON output written to {output_json}')
+
+        logger.info('Creating the GeoJSON from the FMV Data')
+        frame_geojson = create_geojson_and_bbox(frames)
+
+        transcoded_path = Path(temp_dir, 'transcoded.mp4')
+        transcode_cmd = [
+            'ffmpeg',
+            '-i',
+            str(raw_data_path),
+            '-c:v',
+            'libx264',
+            '-preset',
+            'fast',
+            '-crf',
+            '23',
+            str(transcoded_path),
+        ]
+        try:
+            subprocess.run(transcode_cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            logger.error(f'Error during video transcoding: {e}')
+            return
+
+        # Get the metadata from the video file using ffprobe
+        ffprobe_cmd = [
+            'ffprobe',
+            '-v',
+            'error',
+            '-select_streams',
+            'v:0',
+            '-show_entries',
+            'stream=width,height,avg_frame_rate,nb_frames',
+            '-of',
+            'json',
+            str(transcoded_path),
+        ]
+        try:
+            ffprobe_result = subprocess.run(ffprobe_cmd, capture_output=True, text=True, check=True)
+            ffprobe_data = json.loads(ffprobe_result.stdout)
+            stream = ffprobe_data['streams'][0]
+            width = int(stream.get('width', 0))
+            height = int(stream.get('height', 0))
+            # avg_frame_rate is like "25/1"
+            avg_frame_rate = stream.get('avg_frame_rate', '0/1')
+            if '/' in avg_frame_rate:
+                num, denom = avg_frame_rate.split('/')
+                fps = float(num) / float(denom) if float(denom) != 0 else 0
+            else:
+                fps = float(avg_frame_rate)
+            frame_count = int(stream.get('nb_frames', 0))
+        except Exception as e:
+            logger.error(f'Error extracting video metadata: {e}')
+            width = height = frame_count = 0
+            fps = 0.0
+
+        # Read video and GeoJSON into Django content fields
+        with open(transcoded_path, 'rb') as f:
+            fmv_video_file = ContentFile(f.read(), name='video.mp4')
+
+        with open(raw_data_path, 'rb') as f:
+            raw_video_file = ContentFile(f.read(), name=file_name)
+
+        geojson_str = json.dumps(frame_geojson, indent=2)
+        geojson_file = ContentFile(geojson_str.encode('utf-8'), name='vectordata.geojson')
+
+        # Create FMVLayer object
+        fmv_layer = FMVLayer.objects.create(
+            dataset=file_item.dataset,
+            fmv_source_video=raw_video_file,
+            fmv_video=fmv_video_file,
+            geojson_file=geojson_file,
+            default_style=style_options,
+            metadata=metadata,
+            name=layer_name,
+            fmv_fps=fps,
+            fmv_frame_count=frame_count,
+            fmv_video_width=width,
+            fmv_video_height=height,
+        )
+
+        # Set bounds from GeoJSON
+        fmv_layer.set_bounds()
+
+        # Create FMVVectorFeature entries
+        for feature in frame_geojson['features']:
+            geometry = GEOSGeometry(json.dumps(feature['geometry']))
+            FMVVectorFeature.objects.create(
+                map_layer=fmv_layer, geometry=geometry, properties=feature['properties']
+            )
+
+        logger.info(
+            f'Successfully created FMVLayer: {fmv_layer.id} with {len(frame_geojson["features"])} features'
+        )
+        return fmv_layer
+
+
+def create_geojson_and_bbox(
+    frames,
+):
+    geod = pyproj.Geod(ellps='WGS84')
+    features = []
+    polygons = []
+    frame_polygons = []
+    frame_to_bbox = {}
+
+    for frame in frames:
+        try:
+            frame_id = frame.get('Frame ID', None)
+            if frame_id is None:
+                continue
+
+            # Sensor location
+            sensor_lat = float(frame['Sensor Geodetic Latitude (EPSG:4326)'])
+            sensor_lon = float(frame['Sensor Geodetic Longitude (EPSG:4326)'])
+
+            # Frame center and bounding
+            center_lat = float(frame['Geodetic Frame Center Latitude (EPSG:4326)'])
+            center_lon = float(frame['Geodetic Frame Center Longitude (EPSG:4326)'])
+            target_width = float(frame['Target Width (meters)'])
+            image_width = float(frame['Image Width'])
+            image_height = float(frame['Image Height'])
+            platform_heading = float(frame['Platform Heading Angle (degrees)'])
+            sensor_heading = float(frame['Sensor Relative Azimuth Angle (degrees)'])
+            heading = platform_heading + sensor_heading
+            # Build a rectangular footprint centered at the center point, rotated by heading
+            # Compute height in meters based on aspect ratio
+            target_height = (image_height / image_width) * target_width
+
+            # Half dimensions
+            half_width = target_width / 2
+            half_height = target_height / 2
+
+            # Corner offsets (dx, dy) relative to center
+            corner_offsets = [
+                (-half_width, half_height),
+                (half_width, half_height),
+                (half_width, -half_height),
+                (-half_width, -half_height),
+            ]
+
+            corners = []
+            for dx, dy in corner_offsets:
+                distance = (dx**2 + dy**2) ** 0.5
+                angle = (heading + np.degrees(np.arctan2(dx, dy))) % 360
+                lon, lat, _ = geod.fwd(center_lon, center_lat, angle, distance)
+                corners.append((lon, lat))
+            corners.append(corners[0])  # Close polygon
+            polygon = Polygon(corners)
+            polygons.append(polygon)
+            frame_polygons.append((frame_id, polygon))
+            frame_to_bbox[frame_id] = corners
+
+            # Point feature at sensor location
+            point = Point(sensor_lon, sensor_lat)
+            properties = {'fmvType': 'flight_path'}
+            properties['frameId'] = int(frame_id)
+            for key, value in frame.items():
+                properties[key] = value
+
+            feature = {
+                'type': 'Feature',
+                'geometry': mapping(point),
+                'properties': properties,
+            }
+            features.append(feature)
+
+        except (KeyError, ValueError) as e:
+            print(f'Skipping frame due to error: {e}')
+            continue
+
+    # Add unioned polygon
+    if polygons:
+        merged = unary_union(polygons)
+        features.append(
+            {
+                'type': 'Feature',
+                'geometry': mapping(merged),
+                'properties': {'fmvType': 'ground_union'},
+            }
+        )
+
+    # Individual frame bbox polygons with styling
+    for _idx, (frame_id, poly) in enumerate(frame_polygons):
+        feature = {
+            'type': 'Feature',
+            'geometry': mapping(poly),
+            'properties': {
+                'frameId': int(frame_id),
+                'fmvType': 'ground_frame',
+            },
+        }
+        features.append(feature)
+
+    geojson = {'type': 'FeatureCollection', 'features': features}
+
+    return geojson
diff --git a/uvdat/urls.py b/uvdat/urls.py
index ec37311..78c2975 100644
--- a/uvdat/urls.py
+++ b/uvdat/urls.py
@@ -12,6 +12,7 @@
     DerivedRegionViewSet,
     DisplayConfigurationViewSet,
     FileItemViewSet,
+    FMVLayerViewSet,
     LayerCollectionViewSet,
     LayerRepresentationViewSet,
     MapLayerViewSet,
@@ -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')