Skip to main content

ChordSyntenyDisplay

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

Draws a SyntenyTrack in a CircularView, with a ribbon joining the two spans of each alignment.

Example usage

The circular-view display for a SyntenyTrack: each alignment is drawn as a ribbon between its span on one side and its mate's span on the other, so an inversion reads as a twist. The track config below is what creates it; its colors are the config slots on ChordSyntenyDisplay:

{
  type: 'SyntenyTrack',
  trackId: 'volvox_self',
  name: 'Volvox self-alignment',
  assemblyNames: ['volvox', 'volvox'],
  adapter: {
    type: 'PAFAdapter',
    uri: 'https://example.com/volvox_self.paf',
    queryAssembly: 'volvox',
    targetAssembly: 'volvox',
  },
  displays: [
    {
      type: 'ChordSyntenyDisplay',
      displayId: 'volvox_self-ChordSyntenyDisplay',
    },
  ],
}

A track aligning two assemblies needs both of them on the circle, which is the view's assembly: ['hg38', 'mm39'] — see the synteny track guide.

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

MemberDescription
type
type: types.literal('ChordSyntenyDisplay')
configuration
configuration: ConfigurationReference(configSchema)
1 inherited property from one model

From BaseDisplay: id

Volatiles

5 inherited volatiles from 2 models

From BaseChordDisplay: features, reloadCounter

From BaseDisplay: error, statusMessage, statusProgress

Getters

MemberDescription
ready
boolean		loaded, and no reorder this launch asked for still owed. Ribbons drawn before it would be drawn against the arcs it is about to move; a reorder that failed keeps this false and shows as displayPhase error, so a capture never commits the hairball
displayError
unknown		the fetch's error, or else the owed reorder's
featureNoun
string
attributeRanges
Record<string, AttributeRange>		the span or label list each color channel covers over the held alignments, which the view's ramps and key scale to
channelNames
string[]		the color channels the view's modes can paint: the preset measurements and the columns the adapter declares
alignmentEnds
AlignmentEnds[]		each held alignment's two ends by its place in features, on the circle's assemblies and in their canonical refNames: resolved once per fetch, which everything placing, coloring or reordering the alignments reads
ribbonColors
Uint32Array<ArrayBufferLike>		each alignment's packed color under the view's encoding.color, by its place in features. A chromosome mode paints the ideogram color of the chromosome it joins, so a ribbon matches the arc it leaves; a label the view hides paints at zero alpha
shapeAlpha
number		the fill opacity every resting ribbon draws at, the view's opacityLevel; a ribbon's own color alpha (an encoding.color.value's, an encoding.opacity field's fade) rides its lane
ribbonFeet
{ x1: Float32Array<ArrayBuffer>; x2: Float32Array<ArrayBuffer>; y1: Float32Array<ArrayBuffer>; y2: Float32Array<ArrayBuffer>; xGaps: Uint32Array<ArrayBuffer>; yGaps: Uint32Array<ArrayBuffer>; xSlice: Int32Array<ArrayBuffer>; ySlice: Int32Array<ArrayBuffer>; strand: Float32Array<ArrayBuffer>; }
every held alignment's feet on the circle's unrolled axis and the slice index of each end, -1 off the circle, by its place in features: rebuilt by a fetch or a change to the regions, never by a recolor, a zoom or a rotation
ribbonPicks
Uint32Array<ArrayBufferLike>		the alignments the canvas draws, by their place in features, the widest first so every narrower ribbon draws over them: both ends on the circle, and not hidden by the view's color or its filter, which ribbonColors paints at zero alpha
ribbonLanes
RibbonLanes		the drawn alignments as the ribbon mark's lanes, each in its color at that color's own alpha
paintedAssemblyName
string | undefined		the genome whose ideogram this track paints: the second of the two it joins on the circle, none for a genome aligned to itself
paintSpans
ReadonlyMap<number, PaintRun[]>		the stretches of each painted-genome slice covered by the drawn ribbons, by slice index, each in the ideogram color of the first genome's chromosome it comes from; what ideogramPaint bins, and unchanged by a zoom
ideogramPaint
ReadonlyMap<string, PaintRun[]>		the painted genome's ideogram, by slice key: each stretch in the color of the first genome's chromosome that the drawn ribbons over it mostly come from, one bin per CSS px
drawnLanes
RibbonLanes		the ribbon lanes
cappedMeanSpanPx
number		the drawn alignments' mean span on screen, each counted at no more than the width the thin fade stops caring about, which the view's 'auto' fade is decided on
legendColor
string | undefined		the ribbon fill the circle's key shows: the one color every ribbon paints when the view's mode has no key of its own
featureWidgetType
{ type: string; id: string; }		the panel the linear synteny displays open for the same record, so a ribbon clicked on the circle and a ribbon clicked in a synteny view share one drawer entry
partnerSpansBySlice
ReadonlyMap<number, PartnerSpan[]>		each drawn alignment's stretch on each slice it touches, by slice index, named by the chromosome at its other end, with that chromosome's genome where the track joins two
chordCell
ChordCell | undefined		what the view's canvas draws for this display: its lanes while it is ready, nothing while its loading or error ring covers the circle
shapesTestId
string		the test id on the ribbon paths' group, on screen and in the export
29 inherited getters from 2 models

From BaseChordDisplay: view, trackAssemblyNames, fetchInert, loaded, svgReady, displayPhase, radiusPx, curveDepth, bezierRadius, selectedFeatureId, hoveredFeatureId, figureStage, laneIndexById, drawnCount, shapes

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

Methods

MemberDescription
shapeAt
(i: number) => RibbonShape		lane i as the SVG side draws it, on the unrotated figure
shapeLabel
(feature: Feature) => string
alignmentsBetween
(referenceAssembly: string, currentAssembly: string) => AlignmentData[]
the held alignments joining two assemblies on the circle, in canonical refNames and oriented reference side first, which is what the view's reorder reads instead of fetching the file again
partnerSpans
(index: number) => PartnerSpan[]		each drawn alignment's stretch on slice index, named by the chromosome at its other end
laneAt
(x: number, y: number) => number | undefined		the topmost ribbon covering a figure point, measured on the unrotated figure so a rotation keeps the held geometry
renderSvg
() => Promise<Element | null>
trackMenuItems
() => MenuItem[]
11 inherited methods from 2 models

From BaseChordDisplay: shapeFor, shapePathFor, hitAt, assemblyOf, canonicalRefName, axisSlice

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

Actions

MemberDescription
clickFeature
(feature: Feature) => void		what a click on the canvas reaches: the alignment's details
reload
() => void		refetch, and run a reorder this launch still owes, which is how the error ring's Retry reaches a reorder that failed
7 inherited actions from 2 models

From BaseChordDisplay: openErrorDialog, setFeatures

From BaseDisplay: setStatusMessage, setError, clearHoveredFeature, applyDisplaySettings, applyPlot