@abi-software/mapintegratedvuer 1.17.2 → 1.17.3-simulation.1

package/src/mixins/DynamicMarkerMixin.js

@@ -1,6 +1,8 @@
 
 import { mapStores } from 'pinia';
 import { useSettingsStore } from '../stores/settings';
+import { retrieveProtocolData } from '../services/testData.js';
+import { markRaw } from 'vue'
 
 // remove duplicates by stringifying the objects
 const removeDuplicates = function (arrayOfAnything) {
@@ -9,12 +11,18 @@ const removeDuplicates = function (arrayOfAnything) {
     JSON.parse(e)
   )
 }
-  
+
 /* eslint-disable no-alert, no-console */
 export default {
   computed: {
     ...mapStores(useSettingsStore),
   },
+  data: function () {
+    return {
+      protocolData: undefined,
+      markerToUberonID: {},
+    }
+  },
   methods: {
     flatmapPanZoomCallback: function (payload) {
       if (this.mouseHovered) {
@@ -33,22 +41,23 @@ export default {
      */
     flatmapMarkerUpdate(flatmap) {
       if (!this.flatmapReady) return;
+      if (!this.protocolData) {
+        let flatmapImp = flatmap;
+        if (!flatmapImp)
+          flatmapImp = this.getFlatmapImp();
 
-      let flatmapImp = flatmap;
-      if (!flatmapImp)
-        flatmapImp = this.getFlatmapImp();
+        if (flatmapImp) {
+          // Set the dataset markers
+          let markers = this.settingsStore.globalSettings.displayMarkers ? this.settingsStore.markers : [];
+          markers = removeDuplicates(markers);
+          flatmapImp.clearMarkers();
+          flatmapImp.clearDatasetMarkers();
+          flatmapImp.addDatasetMarkers(markers);
 
-      if (flatmapImp) {
-        // Set the dataset markers
-        let markers = this.settingsStore.globalSettings.displayMarkers ? this.settingsStore.markers : [];
-        markers = removeDuplicates(markers);
-        flatmapImp.clearMarkers();
-        flatmapImp.clearDatasetMarkers();
-        flatmapImp.addDatasetMarkers(markers);
-
-        // Set the featured markers
-        if (this.entry.type === "MultiFlatmap") {
-          this.restoreFeaturedMarkers(flatmapImp);
+          // Set the featured markers
+          if (this.entry.type === "MultiFlatmap") {
+            this.restoreFeaturedMarkers(flatmapImp);
+          }
         }
       }
     },
@@ -72,12 +81,36 @@ export default {
       }
       return markersOnFlatmap;
     },
-    flatmapReadyForMarkerUpdates: function (flatmap) {
+    updateProtocolMarkers: function (flatmapImp, ids) {
+      flatmapImp.clearMarkers()
+      if (ids.length > 0) {
+        ids.forEach((id) => {
+          const terms = flatmapImp.sparqlQuery(`
+            prefix bgf: <https://bg-rdf.org/ontologies/bondgraph-framework#>
+            prefix UBERON: <http://purl.obolibrary.org/obo/UBERON_>
+            select ?featureUri where {
+                ?featureUri bgf:hasLocation ?region
+                filter (?region in (${id}))
+            }`)
+            const result = terms[0]
+            const featureUri = result.get('featureUri').value
+            const fID = flatmapImp.addMarkerByFeatureUri(featureUri)
+            this.markerToUberonID[fID] = id
+        })
+      }
+    },
+    flatmapReadyForMarkerUpdates: async function (flatmap) {
       if (flatmap) {
         flatmap.enablePanZoomEvents(true); // Use zoom events for dynamic markers
         this.flatmapReady = true;
         const flatmapImp = flatmap.mapImp;
-        this.flatmapMarkerUpdate(flatmapImp);
+        if (flatmapImp) {
+          const flatmapUUID = flatmapImp.mapMetadata.uuid;
+          this.protocolData = markRaw(await retrieveProtocolData(this.settingsStore.testDataLocation, flatmapUUID));
+          if (!this.protocolData) {
+            this.flatmapMarkerUpdate(flatmapImp);
+          }
+        }
       }
     },
   }

package/src/services/mapping.js

@@ -0,0 +1,69 @@
+import readXlsxFile from 'read-excel-file'
+
+const BASE_URL =
+  'https://raw.githubusercontent.com/hsorby/fc-feature-mapping/main/'
+const INDEX_FILE = 'mapping_index.json'
+
+export class MappingService {
+  // Find the correct Excel file for the current Flatmap
+  static async getMappingIndex() {
+    try {
+      // Fetch the master index
+      const response = await fetch(`${BASE_URL}${INDEX_FILE}`)
+      if (!response.ok) throw new Error('Failed to fetch index')
+
+      const index = await response.json()
+
+      return index || null
+    } catch (e) {
+      console.error('Error finding map mapping:', e)
+      return null
+    }
+  }
+
+  // Fetch and Parse the Excel file
+  static async loadMapping(index) {
+    const flatmapMap = new Map()
+
+    for (const entry in index) {
+      try {
+        const filename = index[entry]
+
+        const response = await fetch(`${BASE_URL}${filename}`)
+        if (!response.ok) throw new Error(`Failed to fetch ${filename}`)
+
+        // Get the binary data
+        const blob = await response.blob()
+
+        // Parse with read-excel-file
+        // rows is an array of arrays: [ ["Header1", "Header2"], ["Row1Col1", "Row1Col2"] ]
+        const rows = await readXlsxFile(blob)
+
+        // Remove header row
+        const headers = rows.shift()
+        const nameIndex = headers.indexOf('Name')
+        const componentIndex = headers.indexOf('Component')
+        const flatmapIdIndex = headers.indexOf('Flatmap ID')
+
+        // Convert to a Lookup Map for fast access
+        // Assuming Column 0 = FlatmapID, Column 1 = Component, Column 2 = Variable
+        const lookup = new Map()
+
+        rows.forEach((row) => {
+          const flatmapId = row[flatmapIdIndex]
+          const component = row[componentIndex]
+          const variable = row[nameIndex]
+
+          if (flatmapId && component && variable) {
+            lookup.set(flatmapId, { component, variable })
+          }
+        })
+        flatmapMap.set(entry, lookup)
+      } catch (e) {
+        console.error('Error parsing mapping file:', e)
+      }
+    }
+
+    return flatmapMap
+  }
+}

package/src/services/testData.js

@@ -0,0 +1,71 @@
+const resolveURL = (relative, base) => {
+  const resolved = new URL(relative, base);
+  return resolved.href;
+}
+
+const readProtocolData = async (item, baseUrl) => {
+  if (item && item.resource?.url) {
+    const resolvedUrl = resolveURL(item.resource.url, baseUrl);
+    const response = await fetch(resolvedUrl)
+    const data = await response.json()
+    //convert url
+    const fields = ["csv_file", "protocol", "thumbnail"]
+    data.forEach((protocol) => {
+      fields.forEach((field) => {
+        if (field in protocol) {
+          protocol[field] = resolveURL(protocol[field], resolvedUrl)
+        }
+      });
+    })
+    return data
+  }
+
+  return
+}
+
+const updateProtocolData = async (entry, baseUrl) => {
+  if (entry["simulation-protocols"]) {
+    const processedData = [];
+    for (const item of entry["simulation-protocols"]) {
+      const data = await readProtocolData(item, baseUrl);
+      if (data) {
+        processedData.push(...data);
+      }
+    }
+    return processedData;
+  }
+}
+
+const getProtocolData = async (uuid, data, baseUrl) => {
+  const processedResults = [];
+  for (const entry of data) {
+    let found = false;
+    if (entry.flatmaps) {
+      for (const flatmap of entry.flatmaps) {
+        if (flatmap.associated_flatmap?.identifier === uuid) {
+          found = true;
+        }
+      }
+    }
+    if (found) {
+      const results = await updateProtocolData(entry, baseUrl);
+      if (results) {
+        processedResults.push(...results);
+      }
+    }
+  }
+  return processedResults;
+}
+
+const retrieveProtocolData = async (url, uuid) => {
+  if (url) {
+    const response = await fetch(url);
+    const data = await response.json();
+    return await getProtocolData(uuid, data, url);
+  }
+  return undefined;
+}
+
+export {
+  retrieveProtocolData
+};

package/src/stores/entries.js

@@ -1,6 +1,6 @@
 import { defineStore } from 'pinia';
 import { initialDefaultState } from "../components/scripts/utilities";
-import { getKnowledgeSourceFromProvenance } from '@abi-software/flatmapvuer/src/services/flatmapKnowledge.js';
+import { getKnowledgeSourceFromProvenance } from '@abi-software/flatmapvuer';
 
 /* eslint-disable no-alert, no-console */
 

package/src/stores/mapping.js

@@ -0,0 +1,29 @@
+import { defineStore } from 'pinia'
+import { MappingService } from '../services/mapping'
+
+export const useMappingStore = defineStore('mapping', {
+  state: () => ({
+    elementMap: new Map(),
+  }),
+
+  actions: {
+    async initializeMapping() {
+      this.elementMap.clear()
+
+      // Find which file to load
+      const index = await MappingService.getMappingIndex()
+
+      if (index) {
+        // Parse and store
+        this.elementMap = await MappingService.loadMapping(index)
+      } else {
+        console.warn('No index found.')
+      }
+    },
+
+    // Helper to get data for a specific element ID
+    mapToCellMLIdentifiers(flatmapUuid, flatmapElementId) {
+      return this.elementMap.get(flatmapUuid)?.get(flatmapElementId) || { component: undefined, variable: undefined }
+    },
+  },
+})

package/src/stores/settings.js

@@ -14,6 +14,7 @@ export const useSettingsStore = defineStore('settings', {
       flatmapAPI: undefined,
       mapManager: undefined,
       rootUrl: undefined,
+      testDataLocation: undefined,
       facets: { species: [], gender: [], organ: [] },
       appliedFacets: [],
       numberOfDatasetsForFacets: [],
@@ -116,6 +117,9 @@ export const useSettingsStore = defineStore('settings', {
     updateRootUrl(rootUrl) {
       this.rootUrl = rootUrl;
     },
+    updateTestDataLocation(testDataLocation) {
+      this.testDataLocation = testDataLocation;
+    },
     updateMarkers(markers) {
       this.markers = markers;
     },

package/src/stores/simulationPlotStore.js

@@ -0,0 +1,124 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import EventBus from '../components/EventBus'
+
+const BASE_Z_INDEX = 100
+
+export const useSimulationPlotStore = defineStore('simulationPlot', () => {
+  const windows = ref([])
+  const zStack = ref([])
+  const simulationEntries = ref({})
+
+  function initListeners() {
+    EventBus.on('simulation-response', handleSimulationResponse)
+    EventBus.on('simulation-ready', handleSimulationReady)
+  }
+
+  function cleanupListeners() {
+    EventBus.off('simulation-response', handleSimulationResponse)
+    EventBus.off('simulation-ready', handleSimulationReady)
+  }
+
+  function removeWindow(windowId) {
+    const targetWindow = windows.value.find(win => win.id === windowId)
+    if (!targetWindow) return
+    windows.value = windows.value.filter((win) => win.id !== windowId)
+    zStack.value = zStack.value.filter((stackId) => stackId !== windowId)
+    EventBus.emit('plot-window-closed', { id: targetWindow.id})
+  }
+
+  function refreshZIndices() {
+    windows.value.forEach((win) => {
+      // Find where this window sits in the stack
+      const stackIndex = zStack.value.indexOf(win.id)
+
+      // If found, assign zIndex. If not (error case), keep it low.
+      if (stackIndex !== -1) {
+        win.zIndex = BASE_Z_INDEX + stackIndex
+      }
+    })
+  }
+
+  function bringToFront(windowId) {
+    const stackIndex = zStack.value.indexOf(windowId)
+    if (stackIndex === -1) return // Should not happen
+
+    zStack.value.splice(stackIndex, 1)
+
+    zStack.value.push(windowId)
+
+    refreshZIndices()
+  }
+
+  function handleSimulationReady(data) {
+    simulationEntries.value[data.resourceId] = { ready: data.ready, entryId: data.entryId }
+  }
+
+  function getEntryIdWithResource(data) {
+    if (!data.resource || !simulationEntries.value[data.resource]?.ready) return 0
+    return simulationEntries.value[data.resource].entryId
+  }
+
+  function runExperimentalData(data) {
+    const entryId = getEntryIdWithResource(data)
+    if (entryId) {
+      console.log("Fire", simulationEntries.value[data.resource].entryId, data)
+      EventBus.emit('simulation-external-data', {
+        targetEntryId: simulationEntries.value[data.resource].entryId,
+        action: data,
+      })
+    }
+    return entryId
+  }
+
+  function requestSimulation(data) {
+    if (data.protocol === null || !simulationEntries.value[data.protocol?.resource]?.ready) return
+
+    let targetWindow = windows.value.find(win => win.id === data.windowId)
+    if (!targetWindow) {
+      targetWindow = {
+        label: data.label,
+        id: data.windowId,
+        ownerId: data.ownerId,
+        data: null,
+        zIndex: BASE_Z_INDEX,
+        x: data.position.x + data.offset.left,
+        y: data.position.y + data.offset.top,
+      }
+      windows.value.push(targetWindow)
+      zStack.value.push(targetWindow.id)
+      refreshZIndices()
+    } else {
+      bringToFront(targetWindow.id)
+    }
+
+    EventBus.emit('simulation-data-request', {
+      id: 'nz.ac.auckland.simulation-data-request',
+      version: '0.1.0',
+      payload: data,
+    })
+  }
+
+  function handleSimulationResponse(response) {
+    if (response.id !== 'nz.ac.auckland.simulation-data-response') return
+    const targetWindow = windows.value.find(win => win.id === response.payload.windowId)
+
+    if (targetWindow) {
+      targetWindow.data = response.payload.data
+    } else {
+      console.warn('Received simulation response for unknown window ID:', response.payload.windowId)
+    }
+  }
+
+  return {
+    windows,
+    bringToFront,
+    cleanupListeners,
+    getEntryIdWithResource,
+    handleSimulationResponse,
+    requestSimulation,
+    runExperimentalData,
+    initListeners,
+    removeWindow,
+  }
+})