@jbrowse/plugin-wiggle 2.0.1 → 2.1.0

package/src/index.ts

@@ -1,105 +1,77 @@
-import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
-import TrackType from '@jbrowse/core/pluggableElementTypes/TrackType'
 import Plugin from '@jbrowse/core/Plugin'
 import PluginManager from '@jbrowse/core/PluginManager'
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-import {
-  createBaseTrackConfig,
-  createBaseTrackModel,
-} from '@jbrowse/core/pluggableElementTypes/models'
-import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType'
 import { FileLocation } from '@jbrowse/core/util/types'
+import {
+  AdapterGuesser,
+  getFileName,
+  TrackTypeGuesser,
+} from '@jbrowse/core/util/tracks'
+
+// locals
 import WiggleBaseRenderer from './WiggleBaseRenderer'
 import WiggleRendering from './WiggleRendering'
-import { configSchema as bigWigAdapterConfigSchema } from './BigWigAdapter'
-import DensityRenderer, {
-  configSchema as densityRendererConfigSchema,
-  ReactComponent as DensityRendererReactComponent,
-} from './DensityRenderer'
+import BigWigAdapterF from './BigWigAdapter'
+import QuantitativeTrackF from './QuantitativeTrack'
+import MultiQuantitativeTrackF from './MultiQuantitativeTrack'
+import MultiWiggleAdapterF from './MultiWiggleAdapter'
+import DensityRendererF from './DensityRenderer'
+import XYPlotRendererF from './XYPlotRenderer'
+import LinePlotRendererF from './LinePlotRenderer'
+import LinearWiggleDisplayF from './LinearWiggleDisplay'
+import MultiLinearWiggleDisplayF from './MultiLinearWiggleDisplay'
+import MultiXYPlotRendererF from './MultiXYPlotRenderer'
+import MultiRowXYPlotRendererF from './MultiRowXYPlotRenderer'
+import MultiDensityRendererF from './MultiDensityRenderer'
+import MultiLineRendererF from './MultiLineRenderer'
+import MultiRowLineRendererF from './MultiRowLineRenderer'
+import CreateMultiWiggleExtensionF from './CreateMultiWiggleExtension'
+import MultiWiggleAddTrackWidgetF from './MultiWiggleAddTrackWidget'
+
 import * as utils from './util'
-import {
-  configSchemaFactory as linearWiggleDisplayConfigSchemaFactory,
-  modelFactory as linearWiggleDisplayModelFactory,
-  ReactComponent as LinearWiggleDisplayReactComponent,
-  YSCALEBAR_LABEL_OFFSET,
-} from './LinearWiggleDisplay'
-import XYPlotRenderer, {
-  configSchema as xyPlotRendererConfigSchema,
-  ReactComponent as XYPlotRendererReactComponent,
-} from './XYPlotRenderer'
-import LinePlotRenderer, {
-  configSchema as linePlotRendererConfigSchema,
-  ReactComponent as LinePlotRendererReactComponent,
-} from './LinePlotRenderer'
+
 import {
   WiggleGetGlobalStats,
   WiggleGetMultiRegionStats,
+  MultiWiggleGetSources,
 } from './WiggleRPC/rpcMethods'
+
 import {
-  AdapterGuesser,
-  getFileName,
-  TrackTypeGuesser,
-} from '@jbrowse/core/util/tracks'
+  ReactComponent as LinearWiggleDisplayReactComponent,
+  modelFactory as linearWiggleDisplayModelFactory,
+  Tooltip,
+} from './LinearWiggleDisplay'
+import { TooltipContentsComponent } from './Tooltip'
+import {
+  ReactComponent as XYPlotRendererReactComponent,
+  configSchema as xyPlotRendererConfigSchema,
+  XYPlotRenderer,
+} from './XYPlotRenderer'
 
 export default class WigglePlugin extends Plugin {
   name = 'WigglePlugin'
 
-  install(pluginManager: PluginManager) {
-    pluginManager.addTrackType(() => {
-      const configSchema = ConfigurationSchema(
-        'QuantitativeTrack',
-        {},
-        { baseConfiguration: createBaseTrackConfig(pluginManager) },
-      )
-      return new TrackType({
-        name: 'QuantitativeTrack',
-        configSchema,
-        stateModel: createBaseTrackModel(
-          pluginManager,
-          'QuantitativeTrack',
-          configSchema,
-        ),
-      })
-    })
-
-    pluginManager.addDisplayType(() => {
-      const configSchema = linearWiggleDisplayConfigSchemaFactory(pluginManager)
-      return new DisplayType({
-        name: 'LinearWiggleDisplay',
-        configSchema,
-        stateModel: linearWiggleDisplayModelFactory(
-          pluginManager,
-          configSchema,
-        ),
-        trackType: 'QuantitativeTrack',
-        viewType: 'LinearGenomeView',
-        ReactComponent: LinearWiggleDisplayReactComponent,
-      })
-    })
+  install(pm: PluginManager) {
+    MultiWiggleAdapterF(pm)
+    BigWigAdapterF(pm)
+    QuantitativeTrackF(pm)
+    MultiQuantitativeTrackF(pm)
+    LinearWiggleDisplayF(pm)
+    MultiLinearWiggleDisplayF(pm)
+    LinePlotRendererF(pm)
+    XYPlotRendererF(pm)
+    DensityRendererF(pm)
+    MultiXYPlotRendererF(pm)
+    MultiRowXYPlotRendererF(pm)
+    MultiDensityRendererF(pm)
+    MultiLineRendererF(pm)
+    MultiRowLineRendererF(pm)
+    MultiWiggleAddTrackWidgetF(pm)
+    CreateMultiWiggleExtensionF(pm)
 
-    pluginManager.addAdapterType(
-      () =>
-        new AdapterType({
-          name: 'BigWigAdapter',
-          configSchema: bigWigAdapterConfigSchema,
-          adapterCapabilities: [
-            'hasResolution',
-            'hasLocalStats',
-            'hasGlobalStats',
-          ],
-          getAdapterClass: () =>
-            import('./BigWigAdapter/BigWigAdapter').then(r => r.default),
-        }),
-    )
-    pluginManager.addToExtensionPoint(
+    pm.addToExtensionPoint(
       'Core-guessAdapterForLocation',
-      (adapterGuesser: AdapterGuesser) => {
-        return (
-          file: FileLocation,
-          index?: FileLocation,
-          adapterHint?: string,
-        ) => {
+      (cb: AdapterGuesser) => {
+        return (file: FileLocation, index?: FileLocation, hint?: string) => {
           const regexGuess = /\.(bw|bigwig)$/i
           const adapterName = 'BigWigAdapter'
           const fileName = getFileName(file)
@@ -108,17 +80,17 @@ export default class WigglePlugin extends Plugin {
             bigWigLocation: file,
           }
 
-          if (regexGuess.test(fileName) && !adapterHint) {
+          if (regexGuess.test(fileName) && !hint) {
             return obj
-          } else if (adapterHint === adapterName) {
+          } else if (hint === adapterName) {
             return obj
           }
 
-          return adapterGuesser(file, index, adapterHint)
+          return cb(file, index, hint)
         }
       },
     )
-    pluginManager.addToExtensionPoint(
+    pm.addToExtensionPoint(
       'Core-guessTrackTypeForLocation',
       (trackTypeGuesser: TrackTypeGuesser) => {
         return (adapterName: string) => {
@@ -130,57 +102,31 @@ export default class WigglePlugin extends Plugin {
       },
     )
 
-    pluginManager.addRendererType(
-      () =>
-        new DensityRenderer({
-          name: 'DensityRenderer',
-          ReactComponent: DensityRendererReactComponent,
-          configSchema: densityRendererConfigSchema,
-          pluginManager,
-        }),
-    )
-
-    pluginManager.addRendererType(
-      () =>
-        new LinePlotRenderer({
-          name: 'LinePlotRenderer',
-          ReactComponent: LinePlotRendererReactComponent,
-          configSchema: linePlotRendererConfigSchema,
-          pluginManager,
-        }),
-    )
-
-    pluginManager.addRendererType(
-      () =>
-        new XYPlotRenderer({
-          name: 'XYPlotRenderer',
-          ReactComponent: XYPlotRendererReactComponent,
-          configSchema: xyPlotRendererConfigSchema,
-          pluginManager,
-        }),
-    )
-
-    pluginManager.addRpcMethod(() => new WiggleGetGlobalStats(pluginManager))
-    pluginManager.addRpcMethod(
-      () => new WiggleGetMultiRegionStats(pluginManager),
-    )
+    pm.addRpcMethod(() => new WiggleGetGlobalStats(pm))
+    pm.addRpcMethod(() => new WiggleGetMultiRegionStats(pm))
+    pm.addRpcMethod(() => new MultiWiggleGetSources(pm))
   }
 
   exports = {
     LinearWiggleDisplayReactComponent,
     XYPlotRendererReactComponent,
     XYPlotRenderer,
+    WiggleBaseRenderer,
+
     xyPlotRendererConfigSchema,
     utils,
-    WiggleBaseRenderer,
     linearWiggleDisplayModelFactory,
   }
 }
 
 export * from './util'
 
-export { WiggleRendering }
-export { WiggleBaseRenderer }
-export { LinearWiggleDisplayReactComponent, linearWiggleDisplayModelFactory }
-export { Tooltip } from './LinearWiggleDisplay/components/Tooltip'
-export { YSCALEBAR_LABEL_OFFSET }
+export {
+  LinearWiggleDisplayReactComponent,
+  Tooltip,
+  WiggleRendering,
+  WiggleBaseRenderer,
+  linearWiggleDisplayModelFactory,
+}
+
+export type { TooltipContentsComponent }

package/src/util.ts

@@ -1,4 +1,20 @@
 import { scaleLinear, scaleLog, scaleQuantize } from 'd3-scale'
+import { autorun } from 'mobx'
+import {
+  isAbortException,
+  getSession,
+  getContainingView,
+} from '@jbrowse/core/util'
+import { FeatureStats } from '@jbrowse/core/util/stats'
+import { getRpcSessionId } from '@jbrowse/core/util/tracks'
+import { addDisposer, isAlive } from 'mobx-state-tree'
+
+import { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
+import { AnyConfigurationModel, getConf } from '@jbrowse/core/configuration'
+
+type LGV = LinearGenomeViewModel
+
+export const YSCALEBAR_LABEL_OFFSET = 5
 
 export interface ScaleOpts {
   domain: number[]
@@ -7,6 +23,13 @@ export interface ScaleOpts {
   pivotValue?: number
   inverted: boolean
 }
+
+export interface Source {
+  name: string
+  color?: string
+  group?: string
+}
+
 /**
  * produces a d3-scale from arguments. applies a "nice domain" adjustment
  *
@@ -143,3 +166,154 @@ export function getNiceDomain({
   scale.nice()
   return scale.domain() as [number, number]
 }
+
+export function groupBy<T>(array: T[], predicate: (v: T) => string) {
+  return array.reduce((acc, value) => {
+    const entry = (acc[predicate(value)] ||= [])
+    entry.push(value)
+    return acc
+  }, {} as { [key: string]: T[] })
+}
+
+export async function getStats(
+  self: {
+    adapterConfig: AnyConfigurationModel
+    autoscaleType: string
+    setMessage: (str: string) => void
+  },
+  opts: {
+    headers?: Record<string, string>
+    signal?: AbortSignal
+    filters?: string[]
+  },
+): Promise<FeatureStats> {
+  const { rpcManager } = getSession(self)
+  const nd = getConf(self, 'numStdDev') || 3
+  const { adapterConfig, autoscaleType } = self
+  const sessionId = getRpcSessionId(self)
+  const params = {
+    sessionId,
+    adapterConfig,
+    statusCallback: (message: string) => {
+      if (isAlive(self)) {
+        self.setMessage(message)
+      }
+    },
+    ...opts,
+  }
+
+  if (autoscaleType === 'global' || autoscaleType === 'globalsd') {
+    const results: FeatureStats = (await rpcManager.call(
+      sessionId,
+      'WiggleGetGlobalStats',
+      params,
+    )) as FeatureStats
+    const { scoreMin, scoreMean, scoreStdDev } = results
+    // globalsd uses heuristic to avoid unnecessary scoreMin<0
+    // if the scoreMin is never less than 0
+    // helps with most coverage bigwigs just being >0
+    return autoscaleType === 'globalsd'
+      ? {
+          ...results,
+          scoreMin: scoreMin >= 0 ? 0 : scoreMean - nd * scoreStdDev,
+          scoreMax: scoreMean + nd * scoreStdDev,
+        }
+      : results
+  }
+  if (autoscaleType === 'local' || autoscaleType === 'localsd') {
+    const { dynamicBlocks, bpPerPx } = getContainingView(self) as LGV
+    const results = (await rpcManager.call(
+      sessionId,
+      'WiggleGetMultiRegionStats',
+      {
+        ...params,
+        regions: dynamicBlocks.contentBlocks.map(region => {
+          const { start, end } = region
+          return {
+            ...JSON.parse(JSON.stringify(region)),
+            start: Math.floor(start),
+            end: Math.ceil(end),
+          }
+        }),
+        bpPerPx,
+      },
+    )) as FeatureStats
+    const { scoreMin, scoreMean, scoreStdDev } = results
+
+    // localsd uses heuristic to avoid unnecessary scoreMin<0 if the
+    // scoreMin is never less than 0 helps with most coverage bigwigs
+    // just being >0
+    return autoscaleType === 'localsd'
+      ? {
+          ...results,
+          scoreMin: scoreMin >= 0 ? 0 : scoreMean - nd * scoreStdDev,
+          scoreMax: scoreMean + nd * scoreStdDev,
+        }
+      : results
+  }
+  if (autoscaleType === 'zscale') {
+    return rpcManager.call(
+      sessionId,
+      'WiggleGetGlobalStats',
+      params,
+    ) as Promise<FeatureStats>
+  }
+  throw new Error(`invalid autoscaleType '${autoscaleType}'`)
+}
+
+export function statsAutorun(self: {
+  estimatedStatsReady: boolean
+  regionTooLarge: boolean
+  setLoading: (aborter: AbortController) => void
+  setError: (error: unknown) => void
+  updateStats: (stats: FeatureStats, statsRegion: string) => void
+  renderProps: () => Record<string, unknown>
+  adapterConfig: AnyConfigurationModel
+  autoscaleType: string
+  setMessage: (str: string) => void
+}) {
+  addDisposer(
+    self,
+    autorun(
+      async () => {
+        try {
+          const aborter = new AbortController()
+          const view = getContainingView(self) as LGV
+          self.setLoading(aborter)
+
+          if (
+            !view.initialized ||
+            !self.estimatedStatsReady ||
+            self.regionTooLarge
+          ) {
+            return
+          }
+          const statsRegion = JSON.stringify(view.dynamicBlocks)
+
+          const wiggleStats = await getStats(self, {
+            signal: aborter.signal,
+            ...self.renderProps(),
+          })
+
+          if (isAlive(self)) {
+            self.updateStats(wiggleStats, statsRegion)
+          }
+        } catch (e) {
+          if (!isAbortException(e) && isAlive(self)) {
+            console.error(e)
+            self.setError(e)
+          }
+        }
+      },
+      { delay: 1000 },
+    ),
+  )
+}
+
+export function toP(s = 0) {
+  return +(+s).toPrecision(6)
+}
+
+export function round(value: number) {
+  return Math.round(value * 1e5) / 1e5
+}

package/src/LinePlotRenderer/LinePlotRenderer.js

@@ -1,91 +0,0 @@
-import { readConfObject } from '@jbrowse/core/configuration'
-import { featureSpanPx } from '@jbrowse/core/util'
-import { getScale } from '../util'
-import WiggleBaseRenderer from '../WiggleBaseRenderer'
-import { YSCALEBAR_LABEL_OFFSET } from '../LinearWiggleDisplay/models/model'
-
-export default class LinePlotRenderer extends WiggleBaseRenderer {
-  async draw(ctx, props) {
-    const {
-      features,
-      regions,
-      bpPerPx,
-      scaleOpts,
-      height: unadjustedHeight,
-      ticks: { values },
-      displayCrossHatches,
-      config,
-    } = props
-    const [region] = regions
-    const width = (region.end - region.start) / bpPerPx
-    const offset = YSCALEBAR_LABEL_OFFSET
-
-    // the adjusted height takes into account YSCALEBAR_LABEL_OFFSET from the
-    // wiggle display, and makes the height of the actual drawn area add
-    // "padding" to the top and bottom of the display
-    const height = unadjustedHeight - offset * 2
-    const clipColor = readConfObject(config, 'clipColor')
-    const highlightColor = readConfObject(config, 'highlightColor')
-    const scale = getScale({ ...scaleOpts, range: [0, height] })
-    const [niceMin, niceMax] = scale.domain()
-    const toY = rawscore => height - scale(rawscore) + offset
-    const colorCallback =
-      readConfObject(config, 'color') === '#f0f'
-        ? () => 'grey'
-        : feature => readConfObject(config, 'color', { feature })
-
-    let lastVal
-    for (const feature of features.values()) {
-      const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
-      const score = feature.get('score')
-      const lowClipping = score < niceMin
-      const highClipping = score > niceMax
-      const w = rightPx - leftPx + 0.3 // fudge factor for subpixel rendering
-
-      const c = colorCallback(feature)
-
-      ctx.strokeStyle = c
-      ctx.beginPath()
-      if (!region.reversed) {
-        ctx.moveTo(
-          leftPx,
-          toY(typeof lastVal !== 'undefined' ? lastVal : score),
-        )
-        ctx.lineTo(leftPx, toY(score))
-        ctx.lineTo(rightPx, toY(score))
-      } else {
-        ctx.moveTo(
-          rightPx,
-          toY(typeof lastVal !== 'undefined' ? lastVal : score),
-        )
-        ctx.lineTo(rightPx, toY(score))
-        ctx.lineTo(leftPx, toY(score))
-      }
-      ctx.stroke()
-      lastVal = score
-
-      if (highClipping) {
-        ctx.fillStyle = clipColor
-        ctx.fillRect(leftPx, 0, w, 4)
-      } else if (lowClipping && scaleOpts.scaleType !== 'log') {
-        ctx.fillStyle = clipColor
-        ctx.fillRect(leftPx, height - 4, w, height)
-      }
-      if (feature.get('highlighted')) {
-        ctx.fillStyle = highlightColor
-        ctx.fillRect(leftPx, 0, w, height)
-      }
-    }
-
-    if (displayCrossHatches) {
-      ctx.lineWidth = 1
-      ctx.strokeStyle = 'rgba(200,200,200,0.8)'
-      values.forEach(tick => {
-        ctx.beginPath()
-        ctx.moveTo(0, Math.round(toY(tick)))
-        ctx.lineTo(width, Math.round(toY(tick)))
-        ctx.stroke()
-      })
-    }
-  }
-}