LinearHicDisplay

Auto-generated from the @jbrowse/mobx-state-tree model in the source — see the developer guide for concepts. Provided by the hic plugin. View source.

The Hi-C contact matrix as a triangle over the view.

Example usage

A HicTrack whose display pins the color scale's top, so two tracks set alike share one scale, and runs one binsize coarser than the zoom picks:

{
  type: 'HicTrack',
  trackId: 'hic',
  name: 'Hi-C',
  assemblyNames: ['hg38'],
  adapter: { type: 'HicAdapter', uri: 'https://example.com/contacts.hic' },
  displays: [
    {
      type: 'LinearHicDisplay',
      displayId: 'hic-LinearHicDisplay',
      encoding: {
        color: { scale: { type: 'symlog', domainMax: 500 } },
      },
      data: { resolution: -1 },
    },
  ],
}

The configuration slots for this model are documented on its config schema page.

Each section ends with the members a composed model contributes, linked to the page that documents them.

Properties

Member	Description
type `type: types.literal('LinearHicDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`

1 inherited property from one model

From BaseDisplay: id

Volatiles

Member	Description
fileInfo `AdapterRead<HicFileInfo> \| undefined`	The file's normalizations and binsizes, stamped with the adapter config they answer.

25 inherited volatiles from 8 models

From PointerHoverMixin: pointer

From TriangleMatrixMixin: rpcData

From LegendMixin: dismissedLegendSections

From KeyedFetchMixin: loadedFetchKey

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, error, statusMessage, statusProgress, fetchCanceled, fetchRotation

From RenderLifecycleMixin: canvasDrawn, paintCount, currentRenderingBackend, renderTick, autorunsInstalled, renderError, offScreen

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From TrackHeightMixin: scrollTop, hostHeight

Getters

Member	Description
availableNormalizations `string[] \| undefined`
availableResolutions `number[] \| undefined`	Smallest first, so a positive `data.resolution` is always finer.
hasControl `boolean`	Whether the adapter names a control, which observed/control needs.
resolutionSteps `number`	`data.resolution`: binsizes finer than the zoom's pick.
colorQuantile `number`	`encoding.color.scale.domainQuantile`: the quantile of the loaded counts an unset `domainMax` follows, their maximum at 1.
colorFollowsPercentile `boolean`	Whether an unset `encoding.color.scale.domainMax` saturates at `colorQuantile` rather than the counts' maximum.
saturationQuantile `number`	The quantile "Emphasize faint contacts" saturates at: `colorQuantile` while it clips, else the one ticking it writes. Each fetch asks the worker for this one whichever is drawn, so the toggle reselects nothing.
selectedNormalization `string`	`data.normalization`, the one asked for.
colorField `"observed" \| "observed/control" \| "observed/expected"`	`encoding.color.field`, what the fetch asks the worker to put in each cell.
paintedColorField `"observed" \| "observed/control" \| "observed/expected"`	The field the loaded cells are: observed/expected falls back to the counts where the file has no expected values at the binsize.
hasResolutions `boolean`	Whether the binsize list has arrived; every resolution control gates on it.
activeNormalization `string`	The normalization to request: the selection where the file has it, else the next best it does. A getter, so a file lacking the selection never marks the track edited.
loadedQuantileScore `number`	The loaded counts' `saturationQuantile`: the worker's answer, or after an edit a selection over the loaded matrix, so a new percentile refetches nothing. The next fetch asks the worker for the new one.
colorDomain `[number, number]`	The domain the counts are colored over, as every ramp spans one: a pinned end holds, and an open one follows the loaded counts from 0, the top at their `colorQuantile` below 1, else their maximum.
awaitingPrerequisite `boolean`	Retry is two-stage: the contact fetch declines until the header it needs lands, and the header's arrival wakes it. `infoFetchFailure.test.ts` pins it.
appliedNormalization `string`	The normalization the loaded matrix has, which falls back per binsize (KR at 5 kb, nothing at 2.5 Mb is typical). The menu ticks this. Fetch-derived, so it stays out of `rpcProps()`.
scaleType `ScaleTypeCode`
colorMidNorm `number`	Where `encoding.color.scale.domainMid` sits on the normalized ramp, 0.5 unset, so a diverging scheme centres on it and equal distances from it take equal colors.
autoResolutionIdx `number`	The binsize index auto mode picks: the largest at most 2 bp/px, about half a bin per pixel, else the finest.
colorScales `ColorScale[]`	The count ramp, once there is a domain to span. The ends are where the ramp paints them, and a top below the largest loaded count reads `≥`. The title names the loaded binsize, so a figure carries it, unless `encoding.color.legend.title` replaces it.
effectiveResolutionIdx `number`	The index in effect after `resolutionSteps`, clamped so steps set at another zoom cannot index out of range.
valueLabel `string`	What the tooltip calls a bin's value.
effectiveResolution `number \| undefined`
canStepResolutionFiner `boolean`
canStepResolutionCoarser `boolean`
renderState `HicRenderState`
viewSignature `string \| undefined`	The static blocks plus the binsize, so a pan inside them redraws and only a block entering or a binsize step refetches. Undefined until the header lands.

83 inherited getters from 11 models

From PointerHoverMixin: hoveredFeature

From TriangleMatrixMixin: heightMode, matrixTop, canvasWidth, viewTransform, matrixRegions, matrixHeight, matrixBlocks, yScalar, triangleTransform, triangleFrame

From MatrixRampMixin: colorEncoding, colorScaleType, colorScheme, colorReverse, colorRamp

From LegendMixin: showLegend, legendRight, legendSpec, hasLegendKey

From GlobalFetchMixin: host, canvasWidthPx, staticBlockSignature, dynamicBlockSignature, viewportEmpty, canRender, rendersCanvas, paintInert, svgReady, displayPhase

From KeyedFetchMixin: dataSuperseded, currentFetchKey, dataCurrent

From FetchMixin: isLoading, isLoadingOrCanceled, fetchInert, awaitingDependentData, settingsFetchInputs

From RenderLifecycleMixin: paintSuperseded, painted

From RegionTooLargeMixin: gateEnabled, byteGateAdapterConfig, configuredFetchSizeLimit, densityTooLarge, byteGateAdapterPath, adapterFetchSizeLimit, configForceLoad, gateViewportSpanBp, gateViewport, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateMeasurementStale, gateByteLimit, gateActive, densityGateActive, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport

From TrackHeightMixin: configuredHeight, allottedHeight, height, resizing, scrollContentHeight, scrollViewportHeight, scrollableHeight

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, featureNoun, featureWidgetType, liveNotices, plotKeys, plot, configNotices, notices, cornerNotices, plotExamples, configDocsUrl

Methods

Member	Description
rpcProps `() => { normalization: string; field: HicColorField; }`	The settings that refetch. The binsize is zoom-derived and the quantile reselects on the main thread, so both ride as call arguments.
hitTest `(mouseX: number, mouseY: number) => HicContactItem \| undefined`	The contact under a display-px point, through the inverse of the transform the matrix was drawn with.
hoverHitAt `(mouseX: number, mouseY: number) => HicContactItem \| undefined`	No contact while the matrix loads: a global display replaces its whole frame, so the cells it holds are on their way out.
trackMenuItems `() => MenuItem[]`
renderSvg `(opts: ExportSvgDisplayOptions) => Promise<ReactNode>`

11 inherited methods from 4 models

From TriangleMatrixMixin: cellToScreen, screenToCell

From LegendMixin: colorScalesIn, legendSpecIn

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From BaseDisplay: renderingProps, configProblemsOf, liftPlot, plotProblems, plotWrites

Actions

Member	Description
startRenderingBackend `(backend: HicRenderingBackend) => void`
setColorField `(field: "observed" \| "observed/control" \| "observed/expected") => void`	What the cells show; a new field starts from its own preset, so a count's scheme or pinned top does not carry onto a ratio.
setLogScale `(log: boolean) => void`	The Log scale toggle: `encoding.color.scale.type` symlog, which keeps every nonzero count visible, or unset for `observed`'s linear preset.
setColorFollowsPercentile `(f: boolean) => void`
setSelectedNormalization `(f: string) => void`
setFileInfo `(read: AdapterRead<HicFileInfo>) => void`
resetResolution `() => void`
setResolutionIdx `(idx: number) => void`	Lock to `availableResolutions[idx]`, clamped, stored as an offset from the auto pick so the choice keeps its meaning across zoom.
setResolution `(binSize: number) => void`	Lock to a binsize the file offers; any other is ignored.
stepResolution `(delta: number) => void`