@apollo-annotation/jbrowse-plugin-apollo 0.3.12 → 1.0.0

package/src/LinearApolloDisplay/stateModel/layouts.ts

@@ -8,43 +8,22 @@ import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree'
 import { autorun, observable } from 'mobx'
 
 import type { ApolloSessionModel } from '../../session'
-import { boxGlyph, geneGlyph, genericChildGlyph } from '../glyphs'
+import {
+  isCDSFeature,
+  isExonFeature,
+  isGeneFeature,
+  isTranscriptFeature,
+} from '../../util/glyphUtils'
+import { boxGlyph } from '../glyphs/BoxGlyph'
+import { cdsGlyph } from '../glyphs/CDSGlyph'
+import { exonGlyph } from '../glyphs/ExonGlyph'
+import { geneGlyph } from '../glyphs/GeneGlyph'
+import { genericChildGlyph } from '../glyphs/GenericChildGlyph'
+import type { Layout } from '../glyphs/Glyph'
+import { transcriptGlyph } from '../glyphs/TranscriptGlyph'
 
 import { baseModelFactory } from './base'
 
-function getRowsForFeature(
-  startingRow: number,
-  rowCount: number,
-  filledRowLocations: Map<number, [number, number][]>,
-) {
-  const rowsForFeature = []
-  for (let i = startingRow; i < startingRow + rowCount; i++) {
-    const row = filledRowLocations.get(i)
-    if (row) {
-      rowsForFeature.push(row)
-    }
-  }
-  return rowsForFeature
-}
-
-function canPlaceFeatureInRows(
-  rowsForFeature: [number, number][][],
-  feature: AnnotationFeature,
-) {
-  for (const rowForFeature of rowsForFeature) {
-    for (const [rowStart, rowEnd] of rowForFeature) {
-      if (
-        doesIntersect2(feature.min, feature.max, rowStart, rowEnd) ||
-        doesIntersect2(rowStart, rowEnd, feature.min, feature.max)
-      ) {
-        return false
-      }
-    }
-  }
-
-  return true
-}
-
 export function layoutsModelFactory(
   pluginManager: PluginManager,
   configSchema: AnyConfigurationSchemaType,
@@ -63,11 +42,19 @@ export function layoutsModelFactory(
         return self.seenFeatures.get(id)
       },
       getGlyph(feature: AnnotationFeature) {
-        const { topLevelFeature } = feature
-        if (topLevelFeature.looksLikeGene) {
+        if (isGeneFeature(feature, self.session)) {
           return geneGlyph
         }
-        if (topLevelFeature.children?.size) {
+        if (isTranscriptFeature(feature, self.session)) {
+          return transcriptGlyph
+        }
+        if (isExonFeature(feature, self.session)) {
+          return exonGlyph
+        }
+        if (isCDSFeature(feature, self.session)) {
+          return cdsGlyph
+        }
+        if (feature.children?.size) {
           return genericChildGlyph
         }
         return boxGlyph
@@ -82,125 +69,198 @@ export function layoutsModelFactory(
       },
     }))
     .views((self) => ({
-      get featureLayouts() {
+      getCanonicalRefName(assemblyName: string, refSeq: string) {
         const { assemblyManager } =
           self.session as unknown as AbstractSessionModel
-        return self.lgv.displayedRegions.map((region) => {
-          const assembly = assemblyManager.get(region.assemblyName)
-          const featureLayout = new Map<number, [number, string][]>()
-          // Track the occupied coordinates in each row
-          const filledRowLocations = new Map<number, [number, number][]>()
+        const assembly = assemblyManager.get(assemblyName)
+        if (!assembly) {
+          throw new Error('no assembly in layout')
+        }
+        const canonicalRefName = assembly.getCanonicalRefName(refSeq)
+        if (!canonicalRefName) {
+          throw new Error('no canonical refName in layout')
+        }
+        return canonicalRefName
+      },
+    }))
+    .views((self) => ({
+      /**
+       * Is a feature in one of the currently displayed regions and also is not
+       * currently filtered out by the display.
+       */
+      isFeatureDisplayed(feature: AnnotationFeature) {
+        const canonicalRefName = self.getCanonicalRefName(
+          feature.assemblyId,
+          feature.refSeq,
+        )
+        return self.lgv.displayedRegions.some((region) => {
           const { end, refName, start } = region
-          for (const [id, feature] of self.seenFeatures.entries()) {
-            if (!isAlive(feature)) {
-              self.deleteSeenFeature(id)
-              continue
-            }
-            if (
-              refName !== assembly?.getCanonicalRefName(feature.refSeq) ||
-              !doesIntersect2(start, end, feature.min, feature.max) ||
-              (self.filteredFeatureTypes.length > 0 &&
-                !self.filteredFeatureTypes.includes(feature.type))
-            ) {
-              continue
-            }
-            const { featureTypeOntology } =
-              self.session.apolloDataStore.ontologyManager
-            if (!featureTypeOntology) {
-              throw new Error('featureTypeOntology is undefined')
-            }
-            const rowCount = self
-              .getGlyph(feature)
-              .getRowCount(feature, featureTypeOntology, self.lgv.bpPerPx)
-            let startingRow = 0
-            let placed = false
-            while (!placed) {
-              let rowsForFeature = getRowsForFeature(
-                startingRow,
-                rowCount,
-                filledRowLocations,
-              )
-              if (rowsForFeature.length < rowCount) {
-                for (let i = 0; i < rowCount - rowsForFeature.length; i++) {
-                  const newRowNumber = filledRowLocations.size
-                  filledRowLocations.set(newRowNumber, [])
-                  featureLayout.set(newRowNumber, [])
-                }
-                rowsForFeature = getRowsForFeature(
-                  startingRow,
-                  rowCount,
-                  filledRowLocations,
-                )
-              }
-              if (!canPlaceFeatureInRows(rowsForFeature, feature)) {
-                startingRow += 1
-                continue
-              }
-              for (
-                let rowNum = startingRow;
-                rowNum < startingRow + rowCount;
-                rowNum++
-              ) {
-                filledRowLocations.get(rowNum)?.push([feature.min, feature.max])
-                const layoutRow = featureLayout.get(rowNum)
-                layoutRow?.push([rowNum - startingRow, feature._id])
-              }
-              placed = true
-            }
+          const hasDisplayedFeatureTypes = self.filteredFeatureTypes.length > 0
+          if (
+            (!hasDisplayedFeatureTypes ||
+              self.filteredFeatureTypes.includes(feature.type)) &&
+            canonicalRefName === refName &&
+            doesIntersect2(start, end, feature.min, feature.max)
+          ) {
+            return true
           }
-          return featureLayout
+          return false
         })
       },
-      getFeatureLayoutPosition(feature: AnnotationFeature) {
-        const { featureLayouts } = this
-        const { featureTypeOntology } =
-          self.session.apolloDataStore.ontologyManager
-        for (const [idx, layout] of featureLayouts.entries()) {
-          for (const [layoutRowNum, layoutRow] of layout) {
-            for (const [featureRowNum, layoutFeatureId] of layoutRow) {
-              if (featureRowNum !== 0) {
-                // Same top-level feature in all feature rows, so only need to
-                // check the first one
-                continue
-              }
-              const layoutFeature =
-                self.getAnnotationFeatureById(layoutFeatureId)
-              if (!layoutFeature) {
-                continue
+    }))
+    .views((self) => ({
+      get layouts(): Map<string, Map<string, Layout>> {
+        // Each refName in an assembly gets its own layout so that if a feature
+        // is drawn in multiple displayed regions, it has the same layout for
+        // each of them
+        const layoutByAssemblyAndRefName = new Map<
+          string,
+          Map<string, Layout>
+        >()
+        // Go through all the features we know about and add them to th
+        for (const [id, feature] of self.seenFeatures.entries()) {
+          if (!isAlive(feature)) {
+            self.deleteSeenFeature(id)
+            continue
+          }
+          const isDisplayed = self.isFeatureDisplayed(feature)
+          if (!isDisplayed) {
+            continue
+          }
+          // This contains layout information for all the feature's sub-features
+          // as well
+          const featureLayout = self
+            .getGlyph(feature)
+            // @ts-expect-error ts doesn't understand mst extension
+            .getLayout(self, feature)
+          const canonicalRefName = self.getCanonicalRefName(
+            feature.assemblyId,
+            feature.refSeq,
+          )
+          let layoutForAssembly = layoutByAssemblyAndRefName.get(
+            feature.assemblyId,
+          )
+          if (!layoutForAssembly) {
+            layoutForAssembly = new Map<string, Layout>()
+            layoutByAssemblyAndRefName.set(
+              feature.assemblyId,
+              layoutForAssembly,
+            )
+          }
+          const layout = layoutForAssembly.get(canonicalRefName)
+          if (!layout) {
+            // If this refSeq doesn't have a layout yet, use this feature's
+            // layout as a starting layout and move on to the next feature
+            layoutForAssembly.set(canonicalRefName, featureLayout)
+            continue
+          }
+          // Check this feature for collisions in the layout, and increase the
+          // starting row if needed until there are no collisions. Then place
+          // the feature in the layout.
+          let startingRowIndex = 0
+          placeFeature: while (true) {
+            let layoutRow = layout.byRow.at(startingRowIndex)
+            if (!layoutRow) {
+              // We've increased startingRowIndex to a row that doesn't exist in
+              // layout yet. Create new row(s), place the feature in them, and
+              // move on to the next feature
+              layout.byRow.push(...featureLayout.byRow)
+              for (const entry of featureLayout.byFeature.entries()) {
+                const [featureId, rowNumber] = entry
+                layout.byFeature.set(featureId, rowNumber + startingRowIndex)
               }
-              if (feature._id === layoutFeature._id) {
-                return {
-                  layoutIndex: idx,
-                  layoutRow: layoutRowNum,
-                  featureRow: featureRowNum,
+              layout.min = Math.min(layout.min, featureLayout.min)
+              layout.max = Math.max(layout.max, featureLayout.max)
+              break placeFeature
+            }
+            // Check this row for collisions. Also check higher rows for
+            // collisions if the feature layout takes up more than one row.
+            // If there is a collision, set the startingRowIndex to the next
+            // row.
+            const highestRow = startingRowIndex + featureLayout.byRow.length - 1
+            let currentRow = startingRowIndex
+            while (layoutRow && startingRowIndex <= highestRow) {
+              for (const layoutFeature of layoutRow.values()) {
+                if (
+                  doesIntersect2(
+                    featureLayout.min,
+                    featureLayout.max,
+                    layoutFeature.feature.min,
+                    layoutFeature.feature.max,
+                  )
+                ) {
+                  startingRowIndex += 1
+                  continue placeFeature
                 }
               }
-              if (layoutFeature.hasDescendant(feature._id)) {
-                if (!featureTypeOntology) {
-                  throw new Error('featureTypeOntology is undefined')
-                }
-                const row = self
-                  .getGlyph(layoutFeature)
-                  .getRowForFeature(layoutFeature, feature, featureTypeOntology)
-                if (row !== undefined) {
-                  return {
-                    layoutIndex: idx,
-                    layoutRow: layoutRowNum,
-                    featureRow: row,
-                  }
-                }
+              currentRow += 1
+              layoutRow = layout.byRow.at(currentRow)
+            }
+            // Now we have our startingRowIndex. Place feature in the layout,
+            // adding new rows if necessary.
+            for (let i = 0; i < featureLayout.byRow.length; i++) {
+              const layoutRow = layout.byRow.at(startingRowIndex + i)
+              if (layoutRow) {
+                layoutRow.push(...featureLayout.byRow[i])
+              } else {
+                layout.byRow.push(featureLayout.byRow[i])
               }
             }
+            for (const entry of featureLayout.byFeature.entries()) {
+              const [featureId, rowNumber] = entry
+              layout.byFeature.set(featureId, rowNumber + startingRowIndex)
+            }
+            layout.min = Math.min(layout.min, featureLayout.min)
+            layout.max = Math.max(layout.max, featureLayout.max)
+            break placeFeature
           }
         }
-        return
+        return layoutByAssemblyAndRefName
+      },
+      getRowForFeature(feature: AnnotationFeature) {
+        const canonicalRefName = self.getCanonicalRefName(
+          feature.assemblyId,
+          feature.refSeq,
+        )
+        return this.layouts
+          .get(feature.assemblyId)
+          ?.get(canonicalRefName)
+          ?.byFeature.get(feature._id)
+      },
+      getFeaturesAtPosition(
+        assemblyName: string,
+        refName: string,
+        row: number,
+        bp: number,
+      ): AnnotationFeature[] {
+        const assemblyLayouts = this.layouts.get(assemblyName)
+        if (!assemblyLayouts) {
+          return []
+        }
+        const layout = assemblyLayouts.get(refName)
+        if (!layout) {
+          return []
+        }
+        const layoutRow = layout.byRow.at(row)
+        if (!layoutRow) {
+          return []
+        }
+        return layoutRow
+          .filter(({ feature }) => {
+            return bp >= feature.min && bp <= feature.max
+          })
+          .map((row) => row.feature)
       },
     }))
     .views((self) => ({
-      get highestRow() {
+      highestRow(assemblyName: string) {
+        const assemblyLayouts = self.layouts.get(assemblyName)
+        if (!assemblyLayouts) {
+          return 0
+        }
         return Math.max(
           0,
-          ...self.featureLayouts.map((layout) => Math.max(...layout.keys())),
+          ...[...assemblyLayouts.values()].map((layout) => layout.byRow.length),
         )
       },
     }))