@jbrowse/plugin-wiggle 2.4.2 → 2.6.1

package/src/shared/modelShared.ts

@@ -0,0 +1,510 @@
+import {
+  AnyConfigurationSchemaType,
+  ConfigurationReference,
+  getConf,
+  readConfObject,
+} from '@jbrowse/core/configuration'
+import {
+  Feature,
+  getEnv,
+  getSession,
+  isSelectionContainer,
+} from '@jbrowse/core/util'
+import { BaseLinearDisplay } from '@jbrowse/plugin-linear-genome-view'
+import { types } from 'mobx-state-tree'
+
+// locals
+import { getNiceDomain } from '../util'
+import { lazy } from 'react'
+
+// lazies
+const SetMinMaxDlg = lazy(() => import('./SetMinMaxDialog'))
+
+/**
+ * #stateModel SharedWiggleMixin
+ */
+export default function SharedWiggleMixin(
+  configSchema: AnyConfigurationSchemaType,
+) {
+  return types
+    .compose(
+      BaseLinearDisplay,
+      types.model({
+        /**
+         * #property
+         */
+        selectedRendering: types.optional(types.string, ''),
+        /**
+         * #property
+         */
+        resolution: types.optional(types.number, 1),
+        /**
+         * #property
+         */
+        fill: types.maybe(types.boolean),
+        /**
+         * #property
+         */
+        minSize: types.maybe(types.number),
+        /**
+         * #property
+         */
+        color: types.maybe(types.string),
+        /**
+         * #property
+         */
+        posColor: types.maybe(types.string),
+        /**
+         * #property
+         */
+        negColor: types.maybe(types.string),
+        /**
+         * #property
+         */
+        summaryScoreMode: types.maybe(types.string),
+        /**
+         * #property
+         */
+        rendererTypeNameState: types.maybe(types.string),
+        /**
+         * #property
+         */
+        scale: types.maybe(types.string),
+        /**
+         * #property
+         */
+        autoscale: types.maybe(types.string),
+        /**
+         * #property
+         */
+        displayCrossHatches: types.maybe(types.boolean),
+        /**
+         * #property
+         */
+        constraints: types.optional(
+          types.model({
+            max: types.maybe(types.number),
+            min: types.maybe(types.number),
+          }),
+          {},
+        ),
+        /**
+         * #property
+         */
+        configuration: ConfigurationReference(configSchema),
+      }),
+    )
+    .volatile(() => ({
+      message: undefined as undefined | string,
+      stats: undefined as { scoreMin: number; scoreMax: number } | undefined,
+      statsFetchInProgress: undefined as undefined | AbortController,
+    }))
+    .actions(self => ({
+      /**
+       * #action
+       */
+      updateQuantitativeStats(stats: { scoreMin: number; scoreMax: number }) {
+        const { scoreMin, scoreMax } = stats
+        const EPSILON = 0.000001
+        if (!self.stats) {
+          self.stats = { scoreMin, scoreMax }
+        } else if (
+          Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
+          Math.abs(self.stats.scoreMin - scoreMin) > EPSILON
+        ) {
+          self.stats = { scoreMin, scoreMax }
+        }
+      },
+      /**
+       * #action
+       */
+      setColor(color?: string) {
+        self.color = color
+      },
+      /**
+       * #action
+       */
+      setPosColor(color?: string) {
+        self.posColor = color
+      },
+      /**
+       * #action
+       */
+      setNegColor(color?: string) {
+        self.negColor = color
+      },
+
+      /**
+       * #action
+       */
+      setLoading(aborter: AbortController) {
+        const { statsFetchInProgress: statsFetch } = self
+        if (statsFetch !== undefined && !statsFetch.signal.aborted) {
+          statsFetch.abort()
+        }
+        self.statsFetchInProgress = aborter
+      },
+
+      /**
+       * #action
+       * this overrides the BaseLinearDisplayModel to avoid popping up a
+       * feature detail display, but still sets the feature selection on the
+       * model so listeners can detect a click
+       */
+      selectFeature(feature: Feature) {
+        const session = getSession(self)
+        if (isSelectionContainer(session)) {
+          session.setSelection(feature)
+        }
+      },
+
+      /**
+       * #action
+       */
+      setResolution(res: number) {
+        self.resolution = res
+      },
+
+      /**
+       * #action
+       */
+      setFill(fill: number) {
+        if (fill === 0) {
+          self.fill = true
+          self.minSize = 0
+        } else if (fill === 1) {
+          self.fill = false
+          self.minSize = 1
+        } else if (fill === 2) {
+          self.fill = false
+          self.minSize = 2
+        }
+      },
+
+      /**
+       * #action
+       */
+      toggleLogScale() {
+        self.scale = self.scale === 'log' ? 'linear' : 'log'
+      },
+
+      /**
+       * #action
+       */
+      setScaleType(scale?: string) {
+        self.scale = scale
+      },
+
+      /**
+       * #action
+       */
+      setSummaryScoreMode(val: string) {
+        self.summaryScoreMode = val
+      },
+
+      /**
+       * #action
+       */
+      setAutoscale(val: string) {
+        self.autoscale = val
+      },
+
+      /**
+       * #action
+       */
+      setMaxScore(val?: number) {
+        self.constraints.max = val
+      },
+
+      /**
+       * #action
+       */
+      setRendererType(val: string) {
+        self.rendererTypeNameState = val
+      },
+
+      /**
+       * #action
+       */
+      setMinScore(val?: number) {
+        self.constraints.min = val
+      },
+
+      /**
+       * #action
+       */
+      toggleCrossHatches() {
+        self.displayCrossHatches = !self.displayCrossHatches
+      },
+
+      /**
+       * #action
+       */
+      setCrossHatches(cross: boolean) {
+        self.displayCrossHatches = cross
+      },
+    }))
+
+    .views(self => ({
+      /**
+       * #getter
+       */
+      get adapterTypeName() {
+        return self.adapterConfig.type
+      },
+
+      /**
+       * #getter
+       */
+      get rendererTypeNameSimple() {
+        return self.rendererTypeNameState ?? getConf(self, 'defaultRendering')
+      },
+
+      /**
+       * #getter
+       * subclasses can define these, as snpcoverage track does
+       */
+      get filters() {
+        return undefined
+      },
+
+      /**
+       * #getter
+       */
+      get scaleType() {
+        return self.scale ?? getConf(self, 'scaleType')
+      },
+
+      /**
+       * #getter
+       */
+      get maxScore() {
+        return self.constraints.max ?? getConf(self, 'maxScore')
+      },
+
+      /**
+       * #getter
+       */
+      get minScore() {
+        return self.constraints.min ?? getConf(self, 'minScore')
+      },
+    }))
+    .views(self => ({
+      /**
+       * #getter
+       */
+      get adapterCapabilities() {
+        const type = self.adapterTypeName
+        const { pluginManager } = getEnv(self)
+        return pluginManager.getAdapterType(type).adapterCapabilities
+      },
+      /**
+       * #getter
+       */
+      get rendererConfig() {
+        const {
+          color,
+          displayCrossHatches,
+          fill,
+          minSize,
+          negColor,
+          posColor,
+          summaryScoreMode,
+          scaleType,
+          rendererTypeName,
+        } = self
+        const configBlob = getConf(self, ['renderers', rendererTypeName]) || {}
+        return self.rendererType.configSchema.create(
+          {
+            ...configBlob,
+            ...(scaleType ? { scaleType } : {}),
+            ...(fill !== undefined ? { filled: fill } : {}),
+            ...(displayCrossHatches !== undefined
+              ? { displayCrossHatches }
+              : {}),
+            ...(summaryScoreMode !== undefined ? { summaryScoreMode } : {}),
+            ...(color !== undefined ? { color } : {}),
+            ...(negColor !== undefined ? { negColor } : {}),
+            ...(posColor !== undefined ? { posColor } : {}),
+            ...(minSize !== undefined ? { minSize } : {}),
+          },
+          getEnv(self),
+        )
+      },
+
+      /**
+       * #getter
+       */
+      get autoscaleType() {
+        return self.autoscale ?? getConf(self, 'autoscale')
+      },
+    }))
+    .views(self => {
+      let oldDomain: [number, number] = [0, 0]
+      return {
+        /**
+         * #getter
+         */
+        get domain() {
+          const { stats, scaleType, minScore, maxScore } = self
+          if (!stats) {
+            return undefined
+          }
+
+          const ret = getNiceDomain({
+            domain: [stats.scoreMin, stats.scoreMax],
+            bounds: [minScore, maxScore],
+            scaleType,
+          })
+
+          // avoid weird scalebar if log value and empty region displayed
+          if (scaleType === 'log' && ret[1] === Number.MIN_VALUE) {
+            return [0, Number.MIN_VALUE]
+          }
+
+          // avoid returning a new object if it matches the old value
+          if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
+            oldDomain = ret
+          }
+
+          return oldDomain
+        },
+      }
+    })
+    .views(self => ({
+      /**
+       * #getter
+       */
+      get filled(): boolean {
+        const { fill, rendererConfig } = self
+        return fill ?? readConfObject(rendererConfig, 'filled')
+      },
+      /**
+       * #getter
+       */
+      get summaryScoreModeSetting(): string {
+        const { summaryScoreMode: mode, rendererConfig } = self
+        return mode ?? readConfObject(rendererConfig, 'summaryScoreMode')
+      },
+
+      /**
+       * #getter
+       */
+      get scaleOpts() {
+        return {
+          domain: self.domain,
+          stats: self.stats,
+          autoscaleType: self.autoscaleType,
+          scaleType: self.scaleType,
+          inverted: getConf(self, 'inverted'),
+        }
+      },
+
+      /**
+       * #getter
+       */
+      get canHaveFill() {
+        return self.rendererTypeName === 'XYPlotRenderer'
+      },
+
+      /**
+       * #getter
+       */
+      get displayCrossHatchesSetting(): boolean {
+        const { displayCrossHatches: hatches, rendererConfig } = self
+        return hatches ?? readConfObject(rendererConfig, 'displayCrossHatches')
+      },
+      /**
+       * #getter
+       */
+      get hasResolution() {
+        return self.adapterCapabilities.includes('hasResolution')
+      },
+
+      /**
+       * #getter
+       */
+      get hasGlobalStats() {
+        return self.adapterCapabilities.includes('hasGlobalStats')
+      },
+    }))
+    .views(self => ({
+      /**
+       * #method
+       */
+      scoreTrackMenuItems() {
+        return [
+          ...(self.hasResolution
+            ? [
+                {
+                  label: 'Resolution',
+                  subMenu: [
+                    {
+                      label: 'Finer resolution',
+                      onClick: () => self.setResolution(self.resolution * 5),
+                    },
+                    {
+                      label: 'Coarser resolution',
+                      onClick: () => self.setResolution(self.resolution / 5),
+                    },
+                  ],
+                },
+                {
+                  label: 'Summary score mode',
+                  subMenu: ['min', 'max', 'avg', 'whiskers'].map(elt => ({
+                    label: elt,
+                    type: 'radio',
+                    checked: self.summaryScoreModeSetting === elt,
+                    onClick: () => self.setSummaryScoreMode(elt),
+                  })),
+                },
+              ]
+            : []),
+          {
+            label:
+              self.scaleType === 'log' ? 'Set linear scale' : 'Set log scale',
+            onClick: () => self.toggleLogScale(),
+          },
+          {
+            label: 'Autoscale type',
+            subMenu: [
+              ['local', 'Local'],
+              ...(self.hasGlobalStats
+                ? [
+                    ['global', 'Global'],
+                    ['globalsd', 'Global ± 3σ'],
+                  ]
+                : []),
+              ['localsd', 'Local ± 3σ'],
+            ].map(([val, label]) => ({
+              label,
+              type: 'radio',
+              checked: self.autoscaleType === val,
+              onClick: () => self.setAutoscale(val),
+            })),
+          },
+          {
+            label: 'Set min/max score',
+            onClick: () => {
+              getSession(self).queueDialog(handleClose => [
+                SetMinMaxDlg,
+                { model: self, handleClose },
+              ])
+            },
+          },
+        ]
+      },
+    }))
+    .actions(self => {
+      const { reload: superReload } = self
+      return {
+        /**
+         * #action
+         */
+        async reload() {
+          self.setError()
+          superReload()
+        },
+      }
+    })
+}

package/src/util.ts

@@ -5,7 +5,7 @@ import {
   getSession,
   getContainingView,
 } from '@jbrowse/core/util'
-import { FeatureStats } from '@jbrowse/core/util/stats'
+import { QuantitativeStats } from '@jbrowse/core/util/stats'
 import { getRpcSessionId } from '@jbrowse/core/util/tracks'
 import { addDisposer, isAlive } from 'mobx-state-tree'
 
@@ -167,18 +167,10 @@ export function getNiceDomain({
   return scale.domain() as [number, number]
 }
 
-export function groupBy<T>(array: T[], predicate: (v: T) => string) {
-  const result = {} as { [key: string]: T[] }
-  for (const value of array) {
-    const entry = (result[predicate(value)] ||= [])
-    entry.push(value)
-  }
-  return result
-}
-
-export async function getStats(
+export async function getQuantitativeStats(
   self: {
     adapterConfig: AnyConfigurationModel
+    configuration: AnyConfigurationModel
     autoscaleType: string
     setMessage: (str: string) => void
   },
@@ -187,7 +179,7 @@ export async function getStats(
     signal?: AbortSignal
     filters?: string[]
   },
-): Promise<FeatureStats> {
+): Promise<QuantitativeStats> {
   const { rpcManager } = getSession(self)
   const nd = getConf(self, 'numStdDev') || 3
   const { adapterConfig, autoscaleType } = self
@@ -204,11 +196,11 @@ export async function getStats(
   }
 
   if (autoscaleType === 'global' || autoscaleType === 'globalsd') {
-    const results: FeatureStats = (await rpcManager.call(
+    const results = (await rpcManager.call(
       sessionId,
-      'WiggleGetGlobalStats',
+      'WiggleGetGlobalQuantitativeStats',
       params,
-    )) as FeatureStats
+    )) as QuantitativeStats
     const { scoreMin, scoreMean, scoreStdDev } = results
     // globalsd uses heuristic to avoid unnecessary scoreMin<0
     // if the scoreMin is never less than 0
@@ -225,7 +217,7 @@ export async function getStats(
     const { dynamicBlocks, bpPerPx } = getContainingView(self) as LGV
     const results = (await rpcManager.call(
       sessionId,
-      'WiggleGetMultiRegionStats',
+      'WiggleGetMultiRegionQuantitativeStats',
       {
         ...params,
         regions: dynamicBlocks.contentBlocks.map(region => {
@@ -238,7 +230,7 @@ export async function getStats(
         }),
         bpPerPx,
       },
-    )) as FeatureStats
+    )) as QuantitativeStats
     const { scoreMin, scoreMean, scoreStdDev } = results
 
     // localsd uses heuristic to avoid unnecessary scoreMin<0 if the
@@ -255,20 +247,25 @@ export async function getStats(
   if (autoscaleType === 'zscale') {
     return rpcManager.call(
       sessionId,
-      'WiggleGetGlobalStats',
+      'WiggleGetGlobalQuantitativeStats',
       params,
-    ) as Promise<FeatureStats>
+    ) as Promise<QuantitativeStats>
   }
   throw new Error(`invalid autoscaleType '${autoscaleType}'`)
 }
 
-export function statsAutorun(self: {
-  estimatedStatsReady: boolean
+export function quantitativeStatsAutorun(self: {
+  featureDensityStatsReady: boolean
   regionTooLarge: boolean
+  error: unknown
   setLoading: (aborter: AbortController) => void
   setError: (error: unknown) => void
-  updateStats: (stats: FeatureStats, statsRegion: string) => void
+  updateQuantitativeStats: (
+    stats: QuantitativeStats,
+    statsRegion: string,
+  ) => void
   renderProps: () => Record<string, unknown>
+  configuration: AnyConfigurationModel
   adapterConfig: AnyConfigurationModel
   autoscaleType: string
   setMessage: (str: string) => void
@@ -284,20 +281,21 @@ export function statsAutorun(self: {
 
           if (
             !view.initialized ||
-            !self.estimatedStatsReady ||
-            self.regionTooLarge
+            !self.featureDensityStatsReady ||
+            self.regionTooLarge ||
+            self.error
           ) {
             return
           }
           const statsRegion = JSON.stringify(view.dynamicBlocks)
 
-          const wiggleStats = await getStats(self, {
+          const wiggleStats = await getQuantitativeStats(self, {
             signal: aborter.signal,
             ...self.renderProps(),
           })
 
           if (isAlive(self)) {
-            self.updateStats(wiggleStats, statsRegion)
+            self.updateQuantitativeStats(wiggleStats, statsRegion)
           }
         } catch (e) {
           if (!isAbortException(e) && isAlive(self)) {