@jbrowse/plugin-alignments 1.6.7 → 1.7.0

package/src/SNPCoverageAdapter/SNPCoverageAdapter.ts

@@ -4,12 +4,14 @@ import {
 } from '@jbrowse/core/data_adapters/BaseAdapter'
 import { AugmentedRegion as Region } from '@jbrowse/core/util/types'
 import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
-import { readConfObject } from '@jbrowse/core/configuration'
-import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { reduce, filter, toArray } from 'rxjs/operators'
-import { Observable } from 'rxjs'
-import { getTag, getTagAlt } from '../util'
+import { toArray } from 'rxjs/operators'
+import {
+  getTag,
+  getTagAlt,
+  fetchSequence,
+  shouldFetchReferenceSequence,
+} from '../util'
 import {
   parseCigar,
   getNextRefPos,
@@ -17,10 +19,6 @@ import {
   Mismatch,
 } from '../BamAdapter/MismatchParser'
 
-interface SNPCoverageOptions extends BaseOptions {
-  filters?: SerializableFilterChain
-}
-
 function mismatchLen(mismatch: Mismatch) {
   return !isInterbase(mismatch.type) ? mismatch.length : 1
 }
@@ -31,11 +29,15 @@ function isInterbase(type: string) {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function inc(bin: any, strand: number, type: string, field: string) {
-  if (!bin[type][field]) {
-    bin[type][field] = { total: 0, strands: { '-1': 0, '0': 0, '1': 0 } }
+  let thisBin = bin[type][field]
+  if (!thisBin) {
+    thisBin = bin[type][field] = {
+      total: 0,
+      strands: { '-1': 0, '0': 0, '1': 0 },
+    }
   }
-  bin[type][field].total++
-  bin[type][field].strands[strand]++
+  thisBin.total++
+  thisBin.strands[strand]++
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function dec(bin: any, strand: number, type: string, field: string) {
@@ -48,11 +50,8 @@ function dec(bin: any, strand: number, type: string, field: string) {
 
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
   protected async configure() {
-    const subadapterConfig = readConfObject(this.config, 'subadapter')
-    const sequenceConf = readConfObject(this.config, [
-      'subadapter',
-      'sequenceAdapter',
-    ])
+    const subadapterConfig = this.getConf('subadapter')
+    const sequenceConf = this.getConf(['subadapter', 'sequenceAdapter'])
     const dataAdapter = await this.getSubAdapter?.(subadapterConfig)
 
     const sequenceAdapter = sequenceConf
@@ -71,18 +70,25 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
     }
   }
 
-  getFeatures(region: Region, opts: SNPCoverageOptions = {}) {
+  async fetchSequence(region: Region) {
+    const { sequenceAdapter } = await this.configure()
+    if (!sequenceAdapter) {
+      return undefined
+    }
+
+    return fetchSequence(region, sequenceAdapter)
+  }
+
+  getFeatures(region: Region, opts: BaseOptions = {}) {
     return ObservableCreate<Feature>(async observer => {
       const { subadapter } = await this.configure()
-      let stream = subadapter.getFeatures(region, opts)
-
-      if (opts.filters) {
-        const { filters } = opts
-        stream = stream.pipe(filter(f => filters.passes(f, opts)))
-      }
+      const feats = await subadapter
+        .getFeatures(region, opts)
+        .pipe(toArray())
+        .toPromise()
 
       const { bins, skipmap } = await this.generateCoverageBins(
-        stream,
+        feats,
         region,
         opts,
       )
@@ -90,7 +96,7 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
       bins.forEach((bin, index) => {
         observer.next(
           new SimpleFeature({
-            id: `${this.id}-${region.start}-${index}`,
+            id: `${this.id}-${region.start + index}`,
             data: {
               score: bin.total,
               snpinfo: bin,
@@ -135,22 +141,12 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
 
   freeResources(/* { region } */): void {}
 
-  /**
-   * Generates coverage bins from features which details
-   * the reference, mismatches, strands, and coverage info
-   * @param features - Features of region to be passed in
-   * @param region - Region
-   * @param bpPerPx - base pairs per pixel
-   * @returns Array of nested frequency tables
-   */
   async generateCoverageBins(
-    features: Observable<Feature>,
+    features: Feature[],
     region: Region,
     opts: { bpPerPx?: number; colorBy?: { type: string; tag?: string } },
   ) {
     const { colorBy } = opts
-    const { sequenceAdapter } = await this.configure()
-    const { originalRefName, refName, start, end } = region
     const binMax = Math.ceil(region.end - region.start)
 
     const skipmap = {} as {
@@ -164,227 +160,176 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
       }
     }
 
-    // bins contain cov feature if they contribute to coverage, or noncov which
-    // are interbase or other features that don't contribute to coverage.
-    // delskips are elements that don't contribute to coverage, but should be
-    // reported also (and are not interbase)
+    // bins contain:
+    // - cov feature if they contribute to coverage
+    // - noncov are insertions/clip features that don't contribute to coverage
+    // - delskips deletions or introns that don't contribute to coverage
     type BinType = { total: number; strands: { [key: string]: number } }
 
-    // request an extra +1 on the end to get CpG crossing region boundary
-    let regionSeq: string | undefined
-
-    if (sequenceAdapter) {
-      const [feat] = await sequenceAdapter
-        .getFeatures({
-          refName: originalRefName || refName,
-          start,
-          end: end + 1,
-          assemblyName: region.assemblyName,
-        })
-        .pipe(toArray())
-        .toPromise()
-      regionSeq = feat?.get('seq')
-    }
+    const regionSeq =
+      features.length && shouldFetchReferenceSequence(opts.colorBy?.type)
+        ? await this.fetchSequence(region)
+        : undefined
+
+    const bins = [] as {
+      total: number
+      lowqual: BinType
+      cov: BinType
+      delskips: BinType
+      noncov: BinType
+      ref: BinType
+    }[]
+
+    for (let i = 0; i < features.length; i++) {
+      const feature = features[i]
+      const ops = parseCigar(feature.get('CIGAR'))
+      const fstart = feature.get('start')
+      const fend = feature.get('end')
+      const fstrand = feature.get('strand')
+
+      for (let j = fstart; j < fend; j++) {
+        const i = j - region.start
+        if (i >= 0 && i < binMax) {
+          const bin = bins[i] || {
+            total: 0,
+            lowqual: {} as BinType,
+            cov: {} as BinType,
+            delskips: {} as BinType,
+            noncov: {} as BinType,
+            ref: {} as BinType,
+          }
+          if (j !== fend) {
+            bin.total++
+            inc(bin, fstrand, 'ref', 'ref')
+          }
+          bins[i] = bin
+        }
+      }
 
-    const bins = await features
-      .pipe(
-        reduce(
-          (bins, feature) => {
-            const cigar = feature.get('CIGAR')
-            const fstart = feature.get('start')
-            const fend = feature.get('end')
-            const fstrand = feature.get('strand')
-            const cigarOps = parseCigar(cigar)
-
-            for (let j = fstart; j < fend + 1; j++) {
-              const i = j - region.start
-              if (i >= 0 && i < binMax) {
-                const bin = bins[i] || {
-                  total: 0,
-                  lowqual: {} as BinType,
-                  cov: {} as BinType,
-                  delskips: {} as BinType,
-                  noncov: {} as BinType,
-                  ref: {} as BinType,
-                }
-                if (j !== fend) {
-                  bin.total++
-                  inc(bin, fstrand, 'ref', 'ref')
-                }
-                bins[i] = bin
+      if (colorBy?.type === 'modifications') {
+        const seq = feature.get('seq') as string
+        const mm = (getTagAlt(feature, 'MM', 'Mm') as string) || ''
+
+        getModificationPositions(mm, seq, fstrand).forEach(
+          ({ type, positions }) => {
+            const mod = `mod_${type}`
+            for (const pos of getNextRefPos(ops, positions)) {
+              const epos = pos + fstart - region.start
+              if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
+                const bin = bins[epos]
+                inc(bin, fstrand, 'cov', mod)
               }
             }
+          },
+        )
+      }
 
-            if (colorBy?.type === 'modifications') {
-              const seq = feature.get('seq')
-              const mm = getTagAlt(feature, 'MM', 'Mm') || ''
-
-              const ml =
-                (getTagAlt(feature, 'ML', 'Ml') as number[] | string) || []
-
-              const probabilities = ml
-                ? (typeof ml === 'string'
-                    ? ml.split(',').map(e => +e)
-                    : ml
-                  ).map(e => e / 255)
-                : (getTagAlt(feature, 'MP', 'Mp') as string)
-                    .split('')
-                    .map(s => s.charCodeAt(0) - 33)
-                    .map(elt => Math.min(1, elt / 50))
-
-              let probIndex = 0
-              getModificationPositions(mm, seq, fstrand).forEach(
-                ({ type, positions }) => {
-                  const mod = `mod_${type}`
-                  for (const pos of getNextRefPos(cigarOps, positions)) {
-                    const epos = pos + fstart - region.start
-                    if (
-                      epos >= 0 &&
-                      epos < bins.length &&
-                      pos + fstart < fend
-                    ) {
-                      const bin = bins[epos] || {
-                        total: 0,
-                        lowqual: {} as BinType,
-                        cov: {} as BinType,
-                        delskips: {} as BinType,
-                        noncov: {} as BinType,
-                        ref: {} as BinType,
-                      }
-
-                      if (probabilities[probIndex] > 0.5) {
-                        inc(bin, fstrand, 'cov', mod)
-                      } else {
-                        inc(bin, fstrand, 'lowqual', mod)
-                      }
-                    }
-                    probIndex++
-                  }
-                },
-              )
+      // methylation based coloring takes into account both reference
+      // sequence CpG detection and reads
+      else if (colorBy?.type === 'methylation') {
+        if (!regionSeq) {
+          throw new Error(
+            'no region sequence detected, need sequenceAdapter configuration',
+          )
+        }
+        const seq = feature.get('seq')
+        const mm = getTagAlt(feature, 'MM', 'Mm') || ''
+        const methBins = new Array(region.end - region.start).fill(0)
+
+        getModificationPositions(mm, seq, fstrand).forEach(
+          ({ type, positions }) => {
+            // we are processing methylation
+            if (type === 'm') {
+              for (const pos of getNextRefPos(ops, positions)) {
+                const epos = pos + fstart - region.start
+                if (epos >= 0 && epos < methBins.length) {
+                  methBins[epos] = 1
+                }
+              }
             }
+          },
+        )
 
-            // methylation based coloring takes into account both reference
-            // sequence CpG detection and reads
-            else if (colorBy?.type === 'methylation') {
-              if (!regionSeq) {
-                throw new Error(
-                  'no region sequence detected, need sequenceAdapter configuration',
-                )
-              }
-              const seq = feature.get('seq')
-              const mm = getTagAlt(feature, 'MM', 'Mm') || ''
-              const methBins = new Array(region.end - region.start).fill(0)
-
-              getModificationPositions(mm, seq, fstrand).forEach(
-                ({ type, positions }) => {
-                  // we are processing methylation
-                  if (type === 'm') {
-                    for (const pos of getNextRefPos(cigarOps, positions)) {
-                      const epos = pos + fstart - region.start
-                      if (epos >= 0 && epos < methBins.length) {
-                        methBins[epos] = 1
-                      }
-                    }
-                  }
-                },
-              )
-
-              for (let j = fstart; j < fend; j++) {
-                const i = j - region.start
-                if (i >= 0 && i < bins.length - 1) {
-                  const l1 = regionSeq[i].toLowerCase()
-                  const l2 = regionSeq[i + 1].toLowerCase()
-                  const bin = bins[i]
-                  const bin1 = bins[i + 1]
-
-                  // color
-                  if (l1 === 'c' && l2 === 'g') {
-                    if (methBins[i] || methBins[i + 1]) {
-                      inc(bin, fstrand, 'cov', 'meth')
-                      inc(bin1, fstrand, 'cov', 'meth')
-                      dec(bin, fstrand, 'ref', 'ref')
-                      dec(bin1, fstrand, 'ref', 'ref')
-                    } else {
-                      inc(bin, fstrand, 'cov', 'unmeth')
-                      inc(bin1, fstrand, 'cov', 'unmeth')
-                      dec(bin, fstrand, 'ref', 'ref')
-                      dec(bin1, fstrand, 'ref', 'ref')
-                    }
-                  }
-                }
+        for (let j = fstart; j < fend; j++) {
+          const i = j - region.start
+          if (i >= 0 && i < bins.length - 1) {
+            const l1 = regionSeq[i].toLowerCase()
+            const l2 = regionSeq[i + 1].toLowerCase()
+            const bin = bins[i]
+            const bin1 = bins[i + 1]
+
+            // color
+            if (l1 === 'c' && l2 === 'g') {
+              if (methBins[i] || methBins[i + 1]) {
+                inc(bin, fstrand, 'cov', 'meth')
+                inc(bin1, fstrand, 'cov', 'meth')
+                dec(bin, fstrand, 'ref', 'ref')
+                dec(bin1, fstrand, 'ref', 'ref')
+              } else {
+                inc(bin, fstrand, 'cov', 'unmeth')
+                inc(bin1, fstrand, 'cov', 'unmeth')
+                dec(bin, fstrand, 'ref', 'ref')
+                dec(bin1, fstrand, 'ref', 'ref')
               }
             }
+          }
+        }
+      }
 
-            // normal SNP based coloring
-            else {
-              const mismatches = feature.get('mismatches') as
-                | Mismatch[]
-                | undefined
-
-              if (mismatches) {
-                for (let i = 0; i < mismatches.length; i++) {
-                  const mismatch = mismatches[i]
-                  const ms = fstart + mismatch.start
-                  for (let j = ms; j < ms + mismatchLen(mismatch); j++) {
-                    const epos = j - region.start
-                    if (epos >= 0 && epos < bins.length) {
-                      const bin = bins[epos]
-                      const { base, type } = mismatch
-                      const interbase = isInterbase(type)
-                      if (!interbase) {
-                        dec(bin, fstrand, 'ref', 'ref')
-                      } else {
-                        inc(bin, fstrand, 'noncov', type)
-                      }
-
-                      if (type === 'deletion' || type === 'skip') {
-                        inc(bin, fstrand, 'delskips', type)
-                        bin.total--
-                      } else if (!interbase) {
-                        inc(bin, fstrand, 'cov', base)
-                      }
-                    }
-                  }
+      // normal SNP based coloring
+      else {
+        const mismatches = feature.get('mismatches') as Mismatch[] | undefined
+
+        if (mismatches) {
+          for (let i = 0; i < mismatches.length; i++) {
+            const mismatch = mismatches[i]
+            const mstart = fstart + mismatch.start
+            for (let j = mstart; j < mstart + mismatchLen(mismatch); j++) {
+              const epos = j - region.start
+              if (epos >= 0 && epos < bins.length) {
+                const bin = bins[epos]
+                const { base, type } = mismatch
+                const interbase = isInterbase(type)
+                if (!interbase) {
+                  dec(bin, fstrand, 'ref', 'ref')
+                } else {
+                  inc(bin, fstrand, 'noncov', type)
                 }
 
-                mismatches
-                  .filter(mismatch => mismatch.type === 'skip')
-                  .forEach(mismatch => {
-                    const mstart = feature.get('start') + mismatch.start
-                    const start = mstart
-                    const end = mstart + mismatch.length
-                    const strand = feature.get('strand')
-                    const hash = `${start}_${end}_${strand}`
-                    if (!skipmap[hash]) {
-                      skipmap[hash] = {
-                        feature: feature,
-                        start,
-                        end,
-                        strand,
-                        xs: getTag(feature, 'XS') || getTag(feature, 'TS'),
-                        score: 1,
-                      }
-                    } else {
-                      skipmap[hash].score++
-                    }
-                  })
+                if (type === 'deletion' || type === 'skip') {
+                  inc(bin, fstrand, 'delskips', type)
+                  bin.total--
+                } else if (!interbase) {
+                  inc(bin, fstrand, 'cov', base)
+                }
               }
             }
-
-            return bins
-          },
-          [] as {
-            total: number
-            lowqual: BinType
-            cov: BinType
-            delskips: BinType
-            noncov: BinType
-            ref: BinType
-          }[],
-        ),
-      )
-      .toPromise()
+          }
+
+          mismatches
+            .filter(mismatch => mismatch.type === 'skip')
+            .forEach(mismatch => {
+              const mstart = feature.get('start') + mismatch.start
+              const start = mstart
+              const end = mstart + mismatch.length
+              const strand = feature.get('strand')
+              const hash = `${start}_${end}_${strand}`
+              if (!skipmap[hash]) {
+                skipmap[hash] = {
+                  feature: feature,
+                  start,
+                  end,
+                  strand,
+                  xs: getTag(feature, 'XS') || getTag(feature, 'TS'),
+                  score: 1,
+                }
+              } else {
+                skipmap[hash].score++
+              }
+            })
+        }
+      }
+    }
 
     return { bins, skipmap }
   }

package/src/SNPCoverageRenderer/SNPCoverageRenderer.ts

@@ -71,11 +71,7 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
     }
     const opts = { ...scaleOpts, range: [0, height] }
     const viewScale = getScale(opts)
-    const snpViewScale = getScale({
-      ...opts,
-      range: [0, height],
-      scaleType: 'linear',
-    })
+
     // clipping and insertion indicators, uses a smaller height/2 scale
     const indicatorViewScale = getScale({
       ...opts,
@@ -83,7 +79,6 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
       scaleType: 'linear',
     })
     const originY = getOrigin(scaleOpts.scaleType)
-    const snpOriginY = getOrigin('linear')
 
     const indicatorThreshold = readConfObject(cfg, 'indicatorThreshold')
     const drawInterbaseCounts = readConfObject(cfg, 'drawInterbaseCounts')
@@ -94,13 +89,10 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
     const toY = (n: number) => height - (viewScale(n) || 0) + offset
     const toHeight = (n: number) => toY(originY) - toY(n)
 
-    // this is always linear scale, even when plotted on top of log scale
-    const snpToY = (n: number) => height - (snpViewScale(n) || 0) + offset
     const indicatorToY = (n: number) =>
       height - (indicatorViewScale(n) || 0) + offset
-    const snpToHeight = (n: number) => snpToY(snpOriginY) - snpToY(n)
     const indicatorToHeight = (n: number) =>
-      indicatorToY(snpOriginY) - indicatorToY(n)
+      indicatorToY(getOrigin('linear')) - indicatorToY(n)
 
     const colorForBase: { [key: string]: string } = {
       A: theme.palette.bases.A.main,
@@ -150,6 +142,7 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
       const feature = coverage[i]
       const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
 
+      const score = feature.get('score') as number
       const snpinfo = feature.get('snpinfo') as SNPInfo
       const w = Math.max(rightPx - leftPx + 0.3, 1)
       const totalScore = snpinfo.total
@@ -163,7 +156,15 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
           colorForBase[base] ||
           modificationTagMap[base.replace('mod_', '')] ||
           '#888'
-        ctx.fillRect(leftPx, snpToY(total + curr), w, snpToHeight(total))
+
+        const height = toHeight(score)
+        const bottom = toY(score) + height
+        ctx.fillRect(
+          leftPx,
+          bottom - ((total + curr) / score) * height,
+          w,
+          (total / score) * height,
+        )
         curr += total
       }
 

package/src/util.ts

@@ -1,4 +1,7 @@
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter'
+import { toArray } from 'rxjs/operators'
 import { Feature } from '@jbrowse/core/util/simpleFeature'
+import { AugmentedRegion } from '@jbrowse/core/util'
 // get tag from BAM or CRAM feature, where CRAM uses feature.get('tags') and
 // BAM does not
 export function getTag(feature: Feature, tag: string) {
@@ -76,3 +79,25 @@ export function getColorWGBS(strand: number, base: string) {
   }
   return '#888'
 }
+
+export async function fetchSequence(
+  region: AugmentedRegion,
+  adapter: BaseFeatureDataAdapter,
+) {
+  const { end, originalRefName, refName } = region
+
+  const feats = await adapter
+    .getFeatures({
+      ...region,
+      refName: originalRefName || refName,
+      end: end + 1,
+    })
+    .pipe(toArray())
+    .toPromise()
+  return feats[0]?.get('seq')
+}
+
+// has to check underlying C-G (aka CpG) on the reference sequence
+export function shouldFetchReferenceSequence(type?: string) {
+  return type === 'methylation'
+}