diff --git a/src/mol-geo/representation/structure/visual/polymer-trace-mesh.ts b/src/mol-geo/representation/structure/visual/polymer-trace-mesh.ts
index a5d1d9b7ef78cd0ca5834b256b3621cfde43069c..a32e1e64cf64dfeb9912894b8e61d03438098609 100644
--- a/src/mol-geo/representation/structure/visual/polymer-trace-mesh.ts
+++ b/src/mol-geo/representation/structure/visual/polymer-trace-mesh.ts
@@ -29,6 +29,8 @@ import { SecondaryStructureType, MoleculeType } from 'mol-model/structure/model/
// TODO handle polymer ends properly
// TODO avoid allocating Vec3, use global temp vars
+// TODO move more interpolation code into ./util/polymer/interpolate
+// TODO move direction wedges into separate visual
const t = Mat4.identity()
diff --git a/src/mol-geo/representation/structure/visual/util/polymer.ts b/src/mol-geo/representation/structure/visual/util/polymer.ts
index 7918f8cccb3d0bead2b70f3ef11a4f1db7262824..1054f7c32363ac2b3c5295044301e5d709e2943e 100644
--- a/src/mol-geo/representation/structure/visual/util/polymer.ts
+++ b/src/mol-geo/representation/structure/visual/util/polymer.ts
@@ -4,14 +4,14 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
-import { Unit, StructureElement, ElementIndex, ResidueIndex } from 'mol-model/structure';
-import { Segmentation, OrderedSet, Interval, SortedArray } from 'mol-data/int';
-import { MoleculeType, SecondaryStructureType, AtomRole } from 'mol-model/structure/model/types';
-import Iterator from 'mol-data/iterator';
-import { Vec3 } from 'mol-math/linear-algebra';
+import { Unit, ElementIndex } from 'mol-model/structure';
+import { Segmentation, OrderedSet, Interval } from 'mol-data/int';
import SortedRanges from 'mol-data/int/sorted-ranges';
-import { CoarseSphereConformation, CoarseGaussianConformation } from 'mol-model/structure/model/properties/coarse';
-import { getMoleculeType, getElementIndexForAtomRole } from 'mol-model/structure/util';
+
+export * from './polymer/backbone-iterator'
+export * from './polymer/gap-iterator'
+export * from './polymer/trace-iterator'
+export * from './polymer/interpolate'
export function getPolymerRanges(unit: Unit): SortedRanges<ElementIndex> {
switch (unit.kind) {
@@ -67,504 +67,3 @@ export function getPolymerGapCount(unit: Unit) {
}
return count
}
-
-const tmpNormal = Vec3.zero()
-const tangentVec = Vec3.zero()
-const normalVec = Vec3.zero()
-const binormalVec = Vec3.zero()
-const prevNormal = Vec3.zero()
-const firstControlPoint = Vec3.zero()
-const lastControlPoint = Vec3.zero()
-const firstTangentVec = Vec3.zero()
-const lastTangentVec = Vec3.zero()
-const firstNormalVec = Vec3.zero()
-const lastNormalVec = Vec3.zero()
-/**
- * Populate normalVectors by interpolating from firstDirection to lastDirection with
- * resulting vector perpendicular to tangentVectors and binormalVectors
- */
-export function interpolateNormals(controlPoints: Helpers.NumberArray, tangentVectors: Helpers.NumberArray, normalVectors: Helpers.NumberArray, binormalVectors: Helpers.NumberArray, firstDirection: Vec3, lastDirection: Vec3) {
- const n = controlPoints.length / 3
-
- Vec3.fromArray(firstControlPoint, controlPoints, 0)
- Vec3.fromArray(lastControlPoint, controlPoints, (n - 1) * 3)
- Vec3.fromArray(firstTangentVec, tangentVectors, 0)
- Vec3.fromArray(lastTangentVec, tangentVectors, (n - 1) * 3)
-
- Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, firstControlPoint, firstDirection))
- Vec3.orthogonalize(firstNormalVec, firstTangentVec, tmpNormal)
-
- Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, lastControlPoint, lastDirection))
- Vec3.orthogonalize(lastNormalVec, lastTangentVec, tmpNormal)
-
- if (Vec3.dot(firstNormalVec, lastNormalVec) < 0) {
- Vec3.scale(lastNormalVec, lastNormalVec, -1)
- }
-
- Vec3.copy(prevNormal, firstNormalVec)
-
- for (let i = 0; i < n; ++i) {
- const t = i === 0 ? 0 : 1 / (n - i)
- Vec3.normalize(tmpNormal, Vec3.slerp(tmpNormal, prevNormal, lastNormalVec, t))
-
- Vec3.fromArray(tangentVec, tangentVectors, i * 3)
-
- Vec3.orthogonalize(normalVec, tangentVec, tmpNormal)
- Vec3.toArray(normalVec, normalVectors, i * 3)
-
- Vec3.copy(prevNormal, normalVec)
-
- Vec3.normalize(binormalVec, Vec3.cross(binormalVec, tangentVec, normalVec))
- Vec3.toArray(binormalVec, binormalVectors, i * 3)
- }
-}
-
-/** Iterates over consecutive pairs of residues/coarse elements in polymers */
-export function PolymerBackboneIterator(unit: Unit): Iterator<PolymerBackbonePair> {
- switch (unit.kind) {
- case Unit.Kind.Atomic: return new AtomicPolymerBackboneIterator(unit)
- case Unit.Kind.Spheres:
- case Unit.Kind.Gaussians:
- return new CoarsePolymerBackboneIterator(unit)
- }
-}
-
-interface PolymerBackbonePair {
- centerA: StructureElement
- centerB: StructureElement
-}
-
-function createPolymerBackbonePair (unit: Unit) {
- return {
- centerA: StructureElement.create(unit),
- centerB: StructureElement.create(unit),
- }
-}
-
-const enum AtomicPolymerBackboneIteratorState { nextPolymer, firstResidue, nextResidue, cycle }
-
-export class AtomicPolymerBackboneIterator implements Iterator<PolymerBackbonePair> {
- private value: PolymerBackbonePair
- private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
- private residueIt: Segmentation.SegmentIterator<ResidueIndex>
- private state: AtomicPolymerBackboneIteratorState = AtomicPolymerBackboneIteratorState.nextPolymer
- private residueSegment: Segmentation.Segment<ResidueIndex>
- hasNext: boolean = false;
-
- private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
- const index = getElementIndexForAtomRole(this.unit.model, residueIndex, atomRole)
- // TODO handle case when it returns -1
- const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
- if (elementIndex === -1) {
- console.log('-1', residueIndex, atomRole, index)
- }
- return elementIndex === -1 ? 0 as ElementIndex : elementIndex
- }
-
- move() {
- if (this.state === AtomicPolymerBackboneIteratorState.nextPolymer) {
- while (this.polymerIt.hasNext) {
- this.residueIt.setSegment(this.polymerIt.move());
- if (this.residueIt.hasNext) {
- this.residueSegment = this.residueIt.move()
- this.value.centerB.element = this.getElementIndex(this.residueSegment.index, 'trace')
- this.state = AtomicPolymerBackboneIteratorState.nextResidue
- break
- }
- }
- }
-
- if (this.state === AtomicPolymerBackboneIteratorState.nextResidue) {
- this.residueSegment = this.residueIt.move()
- this.value.centerA.element = this.value.centerB.element
- this.value.centerB.element = this.getElementIndex(this.residueSegment.index, 'trace')
- if (!this.residueIt.hasNext) {
- if (this.unit.model.atomicHierarchy.cyclicPolymerMap.has(this.residueSegment.index)) {
- this.state = AtomicPolymerBackboneIteratorState.cycle
- } else {
- // TODO need to advance to a polymer that has two or more residues (can't assume it has)
- this.state = AtomicPolymerBackboneIteratorState.nextPolymer
- }
- }
- } else if (this.state === AtomicPolymerBackboneIteratorState.cycle) {
- const { cyclicPolymerMap } = this.unit.model.atomicHierarchy
- this.value.centerA.element = this.value.centerB.element
- this.value.centerB.element = this.getElementIndex(cyclicPolymerMap.get(this.residueSegment.index)!, 'trace')
- // TODO need to advance to a polymer that has two or more residues (can't assume it has)
- this.state = AtomicPolymerBackboneIteratorState.nextPolymer
- }
-
- this.hasNext = this.residueIt.hasNext || this.polymerIt.hasNext || this.state === AtomicPolymerBackboneIteratorState.cycle
- return this.value;
- }
-
- constructor(private unit: Unit.Atomic) {
- this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements)
- this.residueIt = Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, unit.elements)
- this.value = createPolymerBackbonePair(unit)
- this.hasNext = this.residueIt.hasNext && this.polymerIt.hasNext
- }
-}
-
-const enum CoarsePolymerBackboneIteratorState { nextPolymer, nextElement }
-
-export class CoarsePolymerBackboneIterator implements Iterator<PolymerBackbonePair> {
- private value: PolymerBackbonePair
- private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
- private polymerSegment: Segmentation.Segment<ResidueIndex>
- private state: CoarsePolymerBackboneIteratorState = CoarsePolymerBackboneIteratorState.nextPolymer
- private elementIndex: number
- hasNext: boolean = false;
-
- move() {
- if (this.state === CoarsePolymerBackboneIteratorState.nextPolymer) {
- if (this.polymerIt.hasNext) {
- this.polymerSegment = this.polymerIt.move();
- this.elementIndex = this.polymerSegment.start
- if (this.elementIndex + 1 < this.polymerSegment.end) {
- this.value.centerB.element = this.unit.elements[this.elementIndex]
- this.state = CoarsePolymerBackboneIteratorState.nextElement
- } else {
- this.state = CoarsePolymerBackboneIteratorState.nextPolymer
- }
- }
- }
-
- if (this.state === CoarsePolymerBackboneIteratorState.nextElement) {
- this.elementIndex += 1
- this.value.centerA.element = this.value.centerB.element
- this.value.centerB.element = this.unit.elements[this.elementIndex]
- if (this.elementIndex + 1 >= this.polymerSegment.end) {
- this.state = CoarsePolymerBackboneIteratorState.nextPolymer
- }
- }
-
- this.hasNext = this.elementIndex + 1 < this.polymerSegment.end || this.polymerIt.hasNext
- return this.value;
- }
-
- constructor(private unit: Unit.Spheres | Unit.Gaussians) {
- this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements);
- this.value = createPolymerBackbonePair(unit)
- this.hasNext = this.polymerIt.hasNext
- }
-}
-
-/** Iterates over gaps, i.e. the stem residues/coarse elements adjacent to gaps */
-export function PolymerGapIterator(unit: Unit): Iterator<PolymerGapPair> {
- switch (unit.kind) {
- case Unit.Kind.Atomic: return new AtomicPolymerGapIterator(unit)
- case Unit.Kind.Spheres:
- case Unit.Kind.Gaussians:
- return new CoarsePolymerGapIterator(unit)
- }
-}
-
-interface PolymerGapPair {
- centerA: StructureElement
- centerB: StructureElement
-}
-
-function createPolymerGapPair (unit: Unit) {
- return {
- centerA: StructureElement.create(unit),
- centerB: StructureElement.create(unit),
- }
-}
-
-export class AtomicPolymerGapIterator implements Iterator<PolymerGapPair> {
- private value: PolymerGapPair
- private gapIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
- hasNext: boolean = false;
-
- private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
- const index = getElementIndexForAtomRole(this.unit.model, residueIndex, atomRole)
- // TODO handle case when it returns -1
- const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
- if (elementIndex === -1) {
- console.log('-1', residueIndex, atomRole, index)
- }
- return elementIndex === -1 ? 0 as ElementIndex : elementIndex
- }
-
- move() {
- const { elements, residueIndex } = this.unit
- const gapSegment = this.gapIt.move();
- this.value.centerA.element = this.getElementIndex(residueIndex[elements[gapSegment.start]], 'trace')
- this.value.centerB.element = this.getElementIndex(residueIndex[elements[gapSegment.end - 1]], 'trace')
- this.hasNext = this.gapIt.hasNext
- return this.value;
- }
-
- constructor(private unit: Unit.Atomic) {
- this.gapIt = SortedRanges.transientSegments(getGapRanges(unit), unit.elements);
- this.value = createPolymerGapPair(unit)
- this.hasNext = this.gapIt.hasNext
- }
-}
-
-export class CoarsePolymerGapIterator implements Iterator<PolymerGapPair> {
- private value: PolymerGapPair
- private gapIt: SortedRanges.Iterator<ElementIndex, ElementIndex>
- hasNext: boolean = false;
-
- move() {
- const gapSegment = this.gapIt.move();
- this.value.centerA.element = this.unit.elements[gapSegment.start]
- this.value.centerB.element = this.unit.elements[gapSegment.end - 1]
- this.hasNext = this.gapIt.hasNext
- return this.value;
- }
-
- constructor(private unit: Unit.Spheres | Unit.Gaussians) {
- this.gapIt = SortedRanges.transientSegments(getGapRanges(unit), unit.elements);
- this.value = createPolymerGapPair(unit)
- this.hasNext = this.gapIt.hasNext
- }
-}
-
-/**
- * Iterates over individual residues/coarse elements in polymers of a unit while
- * providing information about the neighbourhood in the underlying model for drawing splines
- */
-export function PolymerTraceIterator(unit: Unit): Iterator<PolymerTraceElement> {
- switch (unit.kind) {
- case Unit.Kind.Atomic: return new AtomicPolymerTraceIterator(unit)
- case Unit.Kind.Spheres:
- case Unit.Kind.Gaussians:
- return new CoarsePolymerTraceIterator(unit)
- }
-}
-
-interface PolymerTraceElement {
- center: StructureElement
- first: boolean, last: boolean
- secStrucType: SecondaryStructureType
- secStrucChange: boolean
- moleculeType: MoleculeType
- t0: Vec3, t1: Vec3, t2: Vec3, t3: Vec3, t4: Vec3
- d12: Vec3, d23: Vec3
-}
-
-function createPolymerTraceElement (unit: Unit): PolymerTraceElement {
- return {
- center: StructureElement.create(unit),
- first: false, last: false,
- secStrucType: SecondaryStructureType.create(SecondaryStructureType.Flag.NA),
- secStrucChange: false,
- moleculeType: MoleculeType.unknown,
- t0: Vec3.zero(), t1: Vec3.zero(), t2: Vec3.zero(), t3: Vec3.zero(), t4: Vec3.zero(),
- d12: Vec3.create(1, 0, 0), d23: Vec3.create(1, 0, 0),
- }
-}
-
-const enum AtomicPolymerTraceIteratorState { nextPolymer, nextResidue }
-
-export class AtomicPolymerTraceIterator implements Iterator<PolymerTraceElement> {
- private value: PolymerTraceElement
- private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
- private residueIt: Segmentation.SegmentIterator<ResidueIndex>
- private polymerSegment: Segmentation.Segment<ResidueIndex>
- private residueSegmentMin: ResidueIndex
- private residueSegmentMax: ResidueIndex
- private state: AtomicPolymerTraceIteratorState = AtomicPolymerTraceIteratorState.nextPolymer
- private residueAtomSegments: Segmentation<ElementIndex, ResidueIndex>
-
- private p0 = Vec3.zero();
- private p1 = Vec3.zero();
- private p2 = Vec3.zero();
- private p3 = Vec3.zero();
- private p4 = Vec3.zero();
- private p5 = Vec3.zero();
- private p6 = Vec3.zero();
-
- // private v01 = Vec3.zero();
- private v12 = Vec3.zero();
- private v23 = Vec3.zero();
- // private v34 = Vec3.zero();
-
- hasNext: boolean = false;
-
- private pos(target: Vec3, index: number) {
- target[0] = this.unit.model.atomicConformation.x[index]
- target[1] = this.unit.model.atomicConformation.y[index]
- target[2] = this.unit.model.atomicConformation.z[index]
- }
-
- private updateResidueSegmentRange(polymerSegment: Segmentation.Segment<ResidueIndex>) {
- const { index } = this.unit.model.atomicHierarchy.residueAtomSegments
- this.residueSegmentMin = index[this.unit.elements[polymerSegment.start]]
- this.residueSegmentMax = index[this.unit.elements[polymerSegment.end - 1]]
- }
-
- private getAtomIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
- const { cyclicPolymerMap } = this.unit.model.atomicHierarchy
- if (residueIndex < this.residueSegmentMin) {
- const cyclicIndex = cyclicPolymerMap.get(this.residueSegmentMin)
- if (cyclicIndex !== undefined) {
-
- residueIndex = cyclicIndex - (this.residueSegmentMin - residueIndex - 1) as ResidueIndex
- } else {
- residueIndex = this.residueSegmentMin
- }
- } else if (residueIndex > this.residueSegmentMax) {
- const cyclicIndex = cyclicPolymerMap.get(this.residueSegmentMax)
- if (cyclicIndex !== undefined) {
- residueIndex = cyclicIndex + (residueIndex - this.residueSegmentMax - 1) as ResidueIndex
- } else {
- residueIndex = this.residueSegmentMax
- }
- }
- return getElementIndexForAtomRole(this.unit.model, residueIndex as ResidueIndex, atomRole)
- }
-
- private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
- const index = this.getAtomIndex(residueIndex, atomRole)
- // TODO handle case when it returns -1
- const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
- if (elementIndex === -1) {
- console.log('-1', residueIndex, atomRole, index)
- }
- return elementIndex === -1 ? 0 as ElementIndex : elementIndex
- }
-
- private setControlPoint(out: Vec3, p1: Vec3, p2: Vec3, p3: Vec3, residueIndex: ResidueIndex) {
- const ss = this.unit.model.properties.secondaryStructure.type[residueIndex]
- if (SecondaryStructureType.is(ss, SecondaryStructureType.Flag.Beta)) {
- Vec3.scale(out, Vec3.add(out, p1, Vec3.add(out, p3, Vec3.add(out, p2, p2))), 1/4)
- } else {
- Vec3.copy(out, p2)
- }
- }
-
- move() {
- const { residueIt, polymerIt, value } = this
-
- if (this.state === AtomicPolymerTraceIteratorState.nextPolymer) {
- while (polymerIt.hasNext) {
- this.polymerSegment = polymerIt.move();
- residueIt.setSegment(this.polymerSegment);
- this.updateResidueSegmentRange(this.polymerSegment)
- if (residueIt.hasNext) {
- this.state = AtomicPolymerTraceIteratorState.nextResidue
- break
- }
- }
- }
-
- if (this.state === AtomicPolymerTraceIteratorState.nextResidue) {
- const { index: residueIndex } = residueIt.move();
- value.center.element = this.getElementIndex(residueIndex, 'trace')
-
- this.pos(this.p0, this.getAtomIndex(residueIndex - 3 as ResidueIndex, 'trace'))
- this.pos(this.p1, this.getAtomIndex(residueIndex - 2 as ResidueIndex, 'trace'))
- this.pos(this.p2, this.getAtomIndex(residueIndex - 1 as ResidueIndex, 'trace'))
- this.pos(this.p3, this.getAtomIndex(residueIndex, 'trace'))
- this.pos(this.p4, this.getAtomIndex(residueIndex + 1 as ResidueIndex, 'trace'))
- this.pos(this.p5, this.getAtomIndex(residueIndex + 2 as ResidueIndex, 'trace'))
- this.pos(this.p6, this.getAtomIndex(residueIndex + 3 as ResidueIndex, 'trace'))
-
- // this.pos(this.v01, this.getAtomIndex(residueIndex - 2 as ResidueIndex, 'direction'))
- this.pos(this.v12, this.getAtomIndex(residueIndex - 1 as ResidueIndex, 'direction'))
- this.pos(this.v23, this.getAtomIndex(residueIndex, 'direction'))
- // this.pos(this.v34, this.getAtomIndex(residueIndex + 1 as ResidueIndex, 'direction'))
-
- this.value.secStrucType = this.unit.model.properties.secondaryStructure.type[residueIndex]
-
- this.setControlPoint(value.t0, this.p0, this.p1, this.p2, residueIndex - 2 as ResidueIndex)
- this.setControlPoint(value.t1, this.p1, this.p2, this.p3, residueIndex - 1 as ResidueIndex)
- this.setControlPoint(value.t2, this.p2, this.p3, this.p4, residueIndex)
- this.setControlPoint(value.t3, this.p3, this.p4, this.p5, residueIndex + 1 as ResidueIndex)
- this.setControlPoint(value.t4, this.p4, this.p5, this.p6, residueIndex + 2 as ResidueIndex)
-
- Vec3.copy(value.d12, this.v12)
- Vec3.copy(value.d23, this.v23)
-
- value.first = residueIndex === this.residueSegmentMin
- value.last = residueIndex === this.residueSegmentMax
- value.secStrucChange = this.unit.model.properties.secondaryStructure.key[residueIndex] !== this.unit.model.properties.secondaryStructure.key[residueIndex + 1]
- value.moleculeType = getMoleculeType(this.unit.model, residueIndex)
-
- if (!residueIt.hasNext) {
- this.state = AtomicPolymerTraceIteratorState.nextPolymer
- }
- }
-
- this.hasNext = residueIt.hasNext || polymerIt.hasNext
-
- return this.value;
- }
-
- constructor(private unit: Unit.Atomic) {
- this.residueAtomSegments = unit.model.atomicHierarchy.residueAtomSegments
- this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements)
- this.residueIt = Segmentation.transientSegments(this.residueAtomSegments, unit.elements);
- this.value = createPolymerTraceElement(unit)
- this.hasNext = this.residueIt.hasNext && this.polymerIt.hasNext
- }
-}
-
-const enum CoarsePolymerTraceIteratorState { nextPolymer, nextElement }
-
-export class CoarsePolymerTraceIterator implements Iterator<PolymerTraceElement> {
- private value: PolymerTraceElement
- private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
- private polymerSegment: Segmentation.Segment<ResidueIndex>
- private state: CoarsePolymerTraceIteratorState = CoarsePolymerTraceIteratorState.nextPolymer
- private conformation: CoarseSphereConformation | CoarseGaussianConformation
- private elementIndex: number
- hasNext: boolean = false;
-
- private pos(target: Vec3, elementIndex: number) {
- elementIndex = Math.min(Math.max(this.polymerSegment.start, elementIndex), this.polymerSegment.end - 1)
- const index = this.unit.elements[elementIndex]
- target[0] = this.conformation.x[index]
- target[1] = this.conformation.y[index]
- target[2] = this.conformation.z[index]
- }
-
- move() {
- if (this.state === CoarsePolymerTraceIteratorState.nextPolymer) {
- while (this.polymerIt.hasNext) {
- this.polymerSegment = this.polymerIt.move();
- this.elementIndex = this.polymerSegment.start
-
- if (this.elementIndex + 1 < this.polymerSegment.end) {
- this.state = CoarsePolymerTraceIteratorState.nextElement
- break
- }
- }
- }
-
- if (this.state === CoarsePolymerTraceIteratorState.nextElement) {
- this.elementIndex += 1
- this.value.center.element = this.value.center.unit.elements[this.elementIndex]
-
- this.pos(this.value.t0, this.elementIndex - 2)
- this.pos(this.value.t1, this.elementIndex - 1)
- this.pos(this.value.t2, this.elementIndex)
- this.pos(this.value.t3, this.elementIndex + 1)
- this.pos(this.value.t4, this.elementIndex + 2)
-
- this.value.first = this.elementIndex === this.polymerSegment.start
- this.value.last = this.elementIndex === this.polymerSegment.end - 1
-
- if (this.elementIndex + 1 >= this.polymerSegment.end) {
- this.state = CoarsePolymerTraceIteratorState.nextPolymer
- }
- }
-
- this.hasNext = this.elementIndex + 1 < this.polymerSegment.end || this.polymerIt.hasNext
- return this.value;
- }
-
- constructor(private unit: Unit.Spheres | Unit.Gaussians) {
- this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements);
- this.value = createPolymerTraceElement(unit)
- switch (unit.kind) {
- case Unit.Kind.Spheres: this.conformation = unit.model.coarseConformation.spheres; break
- case Unit.Kind.Gaussians: this.conformation = unit.model.coarseConformation.gaussians; break
- }
- this.hasNext = this.polymerIt.hasNext
- }
-}
\ No newline at end of file
diff --git a/src/mol-geo/representation/structure/visual/util/polymer/backbone-iterator.ts b/src/mol-geo/representation/structure/visual/util/polymer/backbone-iterator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eb5dd18cd1ed4d8b4fa7bff7b1717b1e61101269
--- /dev/null
+++ b/src/mol-geo/representation/structure/visual/util/polymer/backbone-iterator.ts
@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Unit, StructureElement, ElementIndex, ResidueIndex } from 'mol-model/structure';
+import { Segmentation, SortedArray } from 'mol-data/int';
+import Iterator from 'mol-data/iterator';
+import SortedRanges from 'mol-data/int/sorted-ranges';
+import { getElementIndexForAtomRole } from 'mol-model/structure/util';
+import { AtomRole } from 'mol-model/structure/model/types';
+import { getPolymerRanges } from '../polymer';
+
+/** Iterates over consecutive pairs of residues/coarse elements in polymers */
+export function PolymerBackboneIterator(unit: Unit): Iterator<PolymerBackbonePair> {
+ switch (unit.kind) {
+ case Unit.Kind.Atomic: return new AtomicPolymerBackboneIterator(unit)
+ case Unit.Kind.Spheres:
+ case Unit.Kind.Gaussians:
+ return new CoarsePolymerBackboneIterator(unit)
+ }
+}
+
+interface PolymerBackbonePair {
+ centerA: StructureElement
+ centerB: StructureElement
+}
+
+function createPolymerBackbonePair (unit: Unit) {
+ return {
+ centerA: StructureElement.create(unit),
+ centerB: StructureElement.create(unit),
+ }
+}
+
+const enum AtomicPolymerBackboneIteratorState { nextPolymer, firstResidue, nextResidue, cycle }
+
+export class AtomicPolymerBackboneIterator implements Iterator<PolymerBackbonePair> {
+ private value: PolymerBackbonePair
+ private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
+ private residueIt: Segmentation.SegmentIterator<ResidueIndex>
+ private state: AtomicPolymerBackboneIteratorState = AtomicPolymerBackboneIteratorState.nextPolymer
+ private residueSegment: Segmentation.Segment<ResidueIndex>
+ hasNext: boolean = false;
+
+ private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
+ const index = getElementIndexForAtomRole(this.unit.model, residueIndex, atomRole)
+ // TODO handle case when it returns -1
+ const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
+ if (elementIndex === -1) {
+ console.log('-1', residueIndex, atomRole, index)
+ }
+ return elementIndex === -1 ? 0 as ElementIndex : elementIndex
+ }
+
+ move() {
+ if (this.state === AtomicPolymerBackboneIteratorState.nextPolymer) {
+ while (this.polymerIt.hasNext) {
+ this.residueIt.setSegment(this.polymerIt.move());
+ if (this.residueIt.hasNext) {
+ this.residueSegment = this.residueIt.move()
+ this.value.centerB.element = this.getElementIndex(this.residueSegment.index, 'trace')
+ this.state = AtomicPolymerBackboneIteratorState.nextResidue
+ break
+ }
+ }
+ }
+
+ if (this.state === AtomicPolymerBackboneIteratorState.nextResidue) {
+ this.residueSegment = this.residueIt.move()
+ this.value.centerA.element = this.value.centerB.element
+ this.value.centerB.element = this.getElementIndex(this.residueSegment.index, 'trace')
+ if (!this.residueIt.hasNext) {
+ if (this.unit.model.atomicHierarchy.cyclicPolymerMap.has(this.residueSegment.index)) {
+ this.state = AtomicPolymerBackboneIteratorState.cycle
+ } else {
+ // TODO need to advance to a polymer that has two or more residues (can't assume it has)
+ this.state = AtomicPolymerBackboneIteratorState.nextPolymer
+ }
+ }
+ } else if (this.state === AtomicPolymerBackboneIteratorState.cycle) {
+ const { cyclicPolymerMap } = this.unit.model.atomicHierarchy
+ this.value.centerA.element = this.value.centerB.element
+ this.value.centerB.element = this.getElementIndex(cyclicPolymerMap.get(this.residueSegment.index)!, 'trace')
+ // TODO need to advance to a polymer that has two or more residues (can't assume it has)
+ this.state = AtomicPolymerBackboneIteratorState.nextPolymer
+ }
+
+ this.hasNext = this.residueIt.hasNext || this.polymerIt.hasNext || this.state === AtomicPolymerBackboneIteratorState.cycle
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Atomic) {
+ this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements)
+ this.residueIt = Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, unit.elements)
+ this.value = createPolymerBackbonePair(unit)
+ this.hasNext = this.residueIt.hasNext && this.polymerIt.hasNext
+ }
+}
+
+const enum CoarsePolymerBackboneIteratorState { nextPolymer, nextElement }
+
+export class CoarsePolymerBackboneIterator implements Iterator<PolymerBackbonePair> {
+ private value: PolymerBackbonePair
+ private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
+ private polymerSegment: Segmentation.Segment<ResidueIndex>
+ private state: CoarsePolymerBackboneIteratorState = CoarsePolymerBackboneIteratorState.nextPolymer
+ private elementIndex: number
+ hasNext: boolean = false;
+
+ move() {
+ if (this.state === CoarsePolymerBackboneIteratorState.nextPolymer) {
+ if (this.polymerIt.hasNext) {
+ this.polymerSegment = this.polymerIt.move();
+ this.elementIndex = this.polymerSegment.start
+ if (this.elementIndex + 1 < this.polymerSegment.end) {
+ this.value.centerB.element = this.unit.elements[this.elementIndex]
+ this.state = CoarsePolymerBackboneIteratorState.nextElement
+ } else {
+ this.state = CoarsePolymerBackboneIteratorState.nextPolymer
+ }
+ }
+ }
+
+ if (this.state === CoarsePolymerBackboneIteratorState.nextElement) {
+ this.elementIndex += 1
+ this.value.centerA.element = this.value.centerB.element
+ this.value.centerB.element = this.unit.elements[this.elementIndex]
+ if (this.elementIndex + 1 >= this.polymerSegment.end) {
+ this.state = CoarsePolymerBackboneIteratorState.nextPolymer
+ }
+ }
+
+ this.hasNext = this.elementIndex + 1 < this.polymerSegment.end || this.polymerIt.hasNext
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Spheres | Unit.Gaussians) {
+ this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements);
+ this.value = createPolymerBackbonePair(unit)
+ this.hasNext = this.polymerIt.hasNext
+ }
+}
\ No newline at end of file
diff --git a/src/mol-geo/representation/structure/visual/util/polymer/gap-iterator.ts b/src/mol-geo/representation/structure/visual/util/polymer/gap-iterator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b91f2894e01ebd89546cee4fafa59514248ee4d
--- /dev/null
+++ b/src/mol-geo/representation/structure/visual/util/polymer/gap-iterator.ts
@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Unit, StructureElement, ElementIndex, ResidueIndex } from 'mol-model/structure';
+import { SortedArray } from 'mol-data/int';
+import { AtomRole } from 'mol-model/structure/model/types';
+import Iterator from 'mol-data/iterator';
+import SortedRanges from 'mol-data/int/sorted-ranges';
+import { getElementIndexForAtomRole } from 'mol-model/structure/util';
+import { getGapRanges } from '../polymer';
+
+/** Iterates over gaps, i.e. the stem residues/coarse elements adjacent to gaps */
+export function PolymerGapIterator(unit: Unit): Iterator<PolymerGapPair> {
+ switch (unit.kind) {
+ case Unit.Kind.Atomic: return new AtomicPolymerGapIterator(unit)
+ case Unit.Kind.Spheres:
+ case Unit.Kind.Gaussians:
+ return new CoarsePolymerGapIterator(unit)
+ }
+}
+
+interface PolymerGapPair {
+ centerA: StructureElement
+ centerB: StructureElement
+}
+
+function createPolymerGapPair (unit: Unit) {
+ return {
+ centerA: StructureElement.create(unit),
+ centerB: StructureElement.create(unit),
+ }
+}
+
+export class AtomicPolymerGapIterator implements Iterator<PolymerGapPair> {
+ private value: PolymerGapPair
+ private gapIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
+ hasNext: boolean = false;
+
+ private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
+ const index = getElementIndexForAtomRole(this.unit.model, residueIndex, atomRole)
+ // TODO handle case when it returns -1
+ const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
+ if (elementIndex === -1) {
+ console.log('-1', residueIndex, atomRole, index)
+ }
+ return elementIndex === -1 ? 0 as ElementIndex : elementIndex
+ }
+
+ move() {
+ const { elements, residueIndex } = this.unit
+ const gapSegment = this.gapIt.move();
+ this.value.centerA.element = this.getElementIndex(residueIndex[elements[gapSegment.start]], 'trace')
+ this.value.centerB.element = this.getElementIndex(residueIndex[elements[gapSegment.end - 1]], 'trace')
+ this.hasNext = this.gapIt.hasNext
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Atomic) {
+ this.gapIt = SortedRanges.transientSegments(getGapRanges(unit), unit.elements);
+ this.value = createPolymerGapPair(unit)
+ this.hasNext = this.gapIt.hasNext
+ }
+}
+
+export class CoarsePolymerGapIterator implements Iterator<PolymerGapPair> {
+ private value: PolymerGapPair
+ private gapIt: SortedRanges.Iterator<ElementIndex, ElementIndex>
+ hasNext: boolean = false;
+
+ move() {
+ const gapSegment = this.gapIt.move();
+ this.value.centerA.element = this.unit.elements[gapSegment.start]
+ this.value.centerB.element = this.unit.elements[gapSegment.end - 1]
+ this.hasNext = this.gapIt.hasNext
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Spheres | Unit.Gaussians) {
+ this.gapIt = SortedRanges.transientSegments(getGapRanges(unit), unit.elements);
+ this.value = createPolymerGapPair(unit)
+ this.hasNext = this.gapIt.hasNext
+ }
+}
diff --git a/src/mol-geo/representation/structure/visual/util/polymer/interpolate.ts b/src/mol-geo/representation/structure/visual/util/polymer/interpolate.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1bf139858e6a841e71df2d72bf86628003e86f8d
--- /dev/null
+++ b/src/mol-geo/representation/structure/visual/util/polymer/interpolate.ts
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Vec3 } from 'mol-math/linear-algebra';
+
+const tmpNormal = Vec3.zero()
+const tangentVec = Vec3.zero()
+const normalVec = Vec3.zero()
+const binormalVec = Vec3.zero()
+const prevNormal = Vec3.zero()
+const firstControlPoint = Vec3.zero()
+const lastControlPoint = Vec3.zero()
+const firstTangentVec = Vec3.zero()
+const lastTangentVec = Vec3.zero()
+const firstNormalVec = Vec3.zero()
+const lastNormalVec = Vec3.zero()
+
+/**
+ * Populate normalVectors by interpolating from firstDirection to lastDirection with
+ * resulting vector perpendicular to tangentVectors and binormalVectors
+ */
+export function interpolateNormals(controlPoints: Helpers.NumberArray, tangentVectors: Helpers.NumberArray, normalVectors: Helpers.NumberArray, binormalVectors: Helpers.NumberArray, firstDirection: Vec3, lastDirection: Vec3) {
+ const n = controlPoints.length / 3
+
+ Vec3.fromArray(firstControlPoint, controlPoints, 0)
+ Vec3.fromArray(lastControlPoint, controlPoints, (n - 1) * 3)
+ Vec3.fromArray(firstTangentVec, tangentVectors, 0)
+ Vec3.fromArray(lastTangentVec, tangentVectors, (n - 1) * 3)
+
+ Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, firstControlPoint, firstDirection))
+ Vec3.orthogonalize(firstNormalVec, firstTangentVec, tmpNormal)
+
+ Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, lastControlPoint, lastDirection))
+ Vec3.orthogonalize(lastNormalVec, lastTangentVec, tmpNormal)
+
+ if (Vec3.dot(firstNormalVec, lastNormalVec) < 0) {
+ Vec3.scale(lastNormalVec, lastNormalVec, -1)
+ }
+
+ Vec3.copy(prevNormal, firstNormalVec)
+
+ for (let i = 0; i < n; ++i) {
+ const t = i === 0 ? 0 : 1 / (n - i)
+ Vec3.normalize(tmpNormal, Vec3.slerp(tmpNormal, prevNormal, lastNormalVec, t))
+
+ Vec3.fromArray(tangentVec, tangentVectors, i * 3)
+
+ Vec3.orthogonalize(normalVec, tangentVec, tmpNormal)
+ Vec3.toArray(normalVec, normalVectors, i * 3)
+
+ Vec3.copy(prevNormal, normalVec)
+
+ Vec3.normalize(binormalVec, Vec3.cross(binormalVec, tangentVec, normalVec))
+ Vec3.toArray(binormalVec, binormalVectors, i * 3)
+ }
+}
\ No newline at end of file
diff --git a/src/mol-geo/representation/structure/visual/util/polymer/trace-iterator.ts b/src/mol-geo/representation/structure/visual/util/polymer/trace-iterator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..363981362c4b190cfd181888dd843416eee44654
--- /dev/null
+++ b/src/mol-geo/representation/structure/visual/util/polymer/trace-iterator.ts
@@ -0,0 +1,261 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Unit, StructureElement, ElementIndex, ResidueIndex } from 'mol-model/structure';
+import { Segmentation, SortedArray } from 'mol-data/int';
+import { MoleculeType, SecondaryStructureType, AtomRole } from 'mol-model/structure/model/types';
+import Iterator from 'mol-data/iterator';
+import { Vec3 } from 'mol-math/linear-algebra';
+import SortedRanges from 'mol-data/int/sorted-ranges';
+import { CoarseSphereConformation, CoarseGaussianConformation } from 'mol-model/structure/model/properties/coarse';
+import { getMoleculeType, getElementIndexForAtomRole } from 'mol-model/structure/util';
+import { getPolymerRanges } from '../polymer';
+
+/**
+ * Iterates over individual residues/coarse elements in polymers of a unit while
+ * providing information about the neighbourhood in the underlying model for drawing splines
+ */
+export function PolymerTraceIterator(unit: Unit): Iterator<PolymerTraceElement> {
+ switch (unit.kind) {
+ case Unit.Kind.Atomic: return new AtomicPolymerTraceIterator(unit)
+ case Unit.Kind.Spheres:
+ case Unit.Kind.Gaussians:
+ return new CoarsePolymerTraceIterator(unit)
+ }
+}
+
+interface PolymerTraceElement {
+ center: StructureElement
+ first: boolean, last: boolean
+ secStrucType: SecondaryStructureType
+ secStrucChange: boolean
+ moleculeType: MoleculeType
+ t0: Vec3, t1: Vec3, t2: Vec3, t3: Vec3, t4: Vec3
+ d12: Vec3, d23: Vec3
+}
+
+function createPolymerTraceElement (unit: Unit): PolymerTraceElement {
+ return {
+ center: StructureElement.create(unit),
+ first: false, last: false,
+ secStrucType: SecondaryStructureType.create(SecondaryStructureType.Flag.NA),
+ secStrucChange: false,
+ moleculeType: MoleculeType.unknown,
+ t0: Vec3.zero(), t1: Vec3.zero(), t2: Vec3.zero(), t3: Vec3.zero(), t4: Vec3.zero(),
+ d12: Vec3.create(1, 0, 0), d23: Vec3.create(1, 0, 0),
+ }
+}
+
+const enum AtomicPolymerTraceIteratorState { nextPolymer, nextResidue }
+
+export class AtomicPolymerTraceIterator implements Iterator<PolymerTraceElement> {
+ private value: PolymerTraceElement
+ private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
+ private residueIt: Segmentation.SegmentIterator<ResidueIndex>
+ private polymerSegment: Segmentation.Segment<ResidueIndex>
+ private residueSegmentMin: ResidueIndex
+ private residueSegmentMax: ResidueIndex
+ private state: AtomicPolymerTraceIteratorState = AtomicPolymerTraceIteratorState.nextPolymer
+ private residueAtomSegments: Segmentation<ElementIndex, ResidueIndex>
+
+ private p0 = Vec3.zero();
+ private p1 = Vec3.zero();
+ private p2 = Vec3.zero();
+ private p3 = Vec3.zero();
+ private p4 = Vec3.zero();
+ private p5 = Vec3.zero();
+ private p6 = Vec3.zero();
+
+ // private v01 = Vec3.zero();
+ private v12 = Vec3.zero();
+ private v23 = Vec3.zero();
+ // private v34 = Vec3.zero();
+
+ hasNext: boolean = false;
+
+ private pos(target: Vec3, index: number) {
+ target[0] = this.unit.model.atomicConformation.x[index]
+ target[1] = this.unit.model.atomicConformation.y[index]
+ target[2] = this.unit.model.atomicConformation.z[index]
+ }
+
+ private updateResidueSegmentRange(polymerSegment: Segmentation.Segment<ResidueIndex>) {
+ const { index } = this.unit.model.atomicHierarchy.residueAtomSegments
+ this.residueSegmentMin = index[this.unit.elements[polymerSegment.start]]
+ this.residueSegmentMax = index[this.unit.elements[polymerSegment.end - 1]]
+ }
+
+ private getAtomIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
+ const { cyclicPolymerMap } = this.unit.model.atomicHierarchy
+ if (residueIndex < this.residueSegmentMin) {
+ const cyclicIndex = cyclicPolymerMap.get(this.residueSegmentMin)
+ if (cyclicIndex !== undefined) {
+
+ residueIndex = cyclicIndex - (this.residueSegmentMin - residueIndex - 1) as ResidueIndex
+ } else {
+ residueIndex = this.residueSegmentMin
+ }
+ } else if (residueIndex > this.residueSegmentMax) {
+ const cyclicIndex = cyclicPolymerMap.get(this.residueSegmentMax)
+ if (cyclicIndex !== undefined) {
+ residueIndex = cyclicIndex + (residueIndex - this.residueSegmentMax - 1) as ResidueIndex
+ } else {
+ residueIndex = this.residueSegmentMax
+ }
+ }
+ return getElementIndexForAtomRole(this.unit.model, residueIndex as ResidueIndex, atomRole)
+ }
+
+ private getElementIndex(residueIndex: ResidueIndex, atomRole: AtomRole) {
+ const index = this.getAtomIndex(residueIndex, atomRole)
+ // TODO handle case when it returns -1
+ const elementIndex = SortedArray.indexOf(this.unit.elements, index) as ElementIndex
+ if (elementIndex === -1) {
+ console.log('-1', residueIndex, atomRole, index)
+ }
+ return elementIndex === -1 ? 0 as ElementIndex : elementIndex
+ }
+
+ private setControlPoint(out: Vec3, p1: Vec3, p2: Vec3, p3: Vec3, residueIndex: ResidueIndex) {
+ const ss = this.unit.model.properties.secondaryStructure.type[residueIndex]
+ if (SecondaryStructureType.is(ss, SecondaryStructureType.Flag.Beta)) {
+ Vec3.scale(out, Vec3.add(out, p1, Vec3.add(out, p3, Vec3.add(out, p2, p2))), 1/4)
+ } else {
+ Vec3.copy(out, p2)
+ }
+ }
+
+ move() {
+ const { residueIt, polymerIt, value } = this
+
+ if (this.state === AtomicPolymerTraceIteratorState.nextPolymer) {
+ while (polymerIt.hasNext) {
+ this.polymerSegment = polymerIt.move();
+ residueIt.setSegment(this.polymerSegment);
+ this.updateResidueSegmentRange(this.polymerSegment)
+ if (residueIt.hasNext) {
+ this.state = AtomicPolymerTraceIteratorState.nextResidue
+ break
+ }
+ }
+ }
+
+ if (this.state === AtomicPolymerTraceIteratorState.nextResidue) {
+ const { index: residueIndex } = residueIt.move();
+ value.center.element = this.getElementIndex(residueIndex, 'trace')
+
+ this.pos(this.p0, this.getAtomIndex(residueIndex - 3 as ResidueIndex, 'trace'))
+ this.pos(this.p1, this.getAtomIndex(residueIndex - 2 as ResidueIndex, 'trace'))
+ this.pos(this.p2, this.getAtomIndex(residueIndex - 1 as ResidueIndex, 'trace'))
+ this.pos(this.p3, this.getAtomIndex(residueIndex, 'trace'))
+ this.pos(this.p4, this.getAtomIndex(residueIndex + 1 as ResidueIndex, 'trace'))
+ this.pos(this.p5, this.getAtomIndex(residueIndex + 2 as ResidueIndex, 'trace'))
+ this.pos(this.p6, this.getAtomIndex(residueIndex + 3 as ResidueIndex, 'trace'))
+
+ // this.pos(this.v01, this.getAtomIndex(residueIndex - 2 as ResidueIndex, 'direction'))
+ this.pos(this.v12, this.getAtomIndex(residueIndex - 1 as ResidueIndex, 'direction'))
+ this.pos(this.v23, this.getAtomIndex(residueIndex, 'direction'))
+ // this.pos(this.v34, this.getAtomIndex(residueIndex + 1 as ResidueIndex, 'direction'))
+
+ this.value.secStrucType = this.unit.model.properties.secondaryStructure.type[residueIndex]
+
+ this.setControlPoint(value.t0, this.p0, this.p1, this.p2, residueIndex - 2 as ResidueIndex)
+ this.setControlPoint(value.t1, this.p1, this.p2, this.p3, residueIndex - 1 as ResidueIndex)
+ this.setControlPoint(value.t2, this.p2, this.p3, this.p4, residueIndex)
+ this.setControlPoint(value.t3, this.p3, this.p4, this.p5, residueIndex + 1 as ResidueIndex)
+ this.setControlPoint(value.t4, this.p4, this.p5, this.p6, residueIndex + 2 as ResidueIndex)
+
+ Vec3.copy(value.d12, this.v12)
+ Vec3.copy(value.d23, this.v23)
+
+ value.first = residueIndex === this.residueSegmentMin
+ value.last = residueIndex === this.residueSegmentMax
+ value.secStrucChange = this.unit.model.properties.secondaryStructure.key[residueIndex] !== this.unit.model.properties.secondaryStructure.key[residueIndex + 1]
+ value.moleculeType = getMoleculeType(this.unit.model, residueIndex)
+
+ if (!residueIt.hasNext) {
+ this.state = AtomicPolymerTraceIteratorState.nextPolymer
+ }
+ }
+
+ this.hasNext = residueIt.hasNext || polymerIt.hasNext
+
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Atomic) {
+ this.residueAtomSegments = unit.model.atomicHierarchy.residueAtomSegments
+ this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements)
+ this.residueIt = Segmentation.transientSegments(this.residueAtomSegments, unit.elements);
+ this.value = createPolymerTraceElement(unit)
+ this.hasNext = this.residueIt.hasNext && this.polymerIt.hasNext
+ }
+}
+
+const enum CoarsePolymerTraceIteratorState { nextPolymer, nextElement }
+
+export class CoarsePolymerTraceIterator implements Iterator<PolymerTraceElement> {
+ private value: PolymerTraceElement
+ private polymerIt: SortedRanges.Iterator<ElementIndex, ResidueIndex>
+ private polymerSegment: Segmentation.Segment<ResidueIndex>
+ private state: CoarsePolymerTraceIteratorState = CoarsePolymerTraceIteratorState.nextPolymer
+ private conformation: CoarseSphereConformation | CoarseGaussianConformation
+ private elementIndex: number
+ hasNext: boolean = false;
+
+ private pos(target: Vec3, elementIndex: number) {
+ elementIndex = Math.min(Math.max(this.polymerSegment.start, elementIndex), this.polymerSegment.end - 1)
+ const index = this.unit.elements[elementIndex]
+ target[0] = this.conformation.x[index]
+ target[1] = this.conformation.y[index]
+ target[2] = this.conformation.z[index]
+ }
+
+ move() {
+ if (this.state === CoarsePolymerTraceIteratorState.nextPolymer) {
+ while (this.polymerIt.hasNext) {
+ this.polymerSegment = this.polymerIt.move();
+ this.elementIndex = this.polymerSegment.start
+
+ if (this.elementIndex + 1 < this.polymerSegment.end) {
+ this.state = CoarsePolymerTraceIteratorState.nextElement
+ break
+ }
+ }
+ }
+
+ if (this.state === CoarsePolymerTraceIteratorState.nextElement) {
+ this.elementIndex += 1
+ this.value.center.element = this.value.center.unit.elements[this.elementIndex]
+
+ this.pos(this.value.t0, this.elementIndex - 2)
+ this.pos(this.value.t1, this.elementIndex - 1)
+ this.pos(this.value.t2, this.elementIndex)
+ this.pos(this.value.t3, this.elementIndex + 1)
+ this.pos(this.value.t4, this.elementIndex + 2)
+
+ this.value.first = this.elementIndex === this.polymerSegment.start
+ this.value.last = this.elementIndex === this.polymerSegment.end - 1
+
+ if (this.elementIndex + 1 >= this.polymerSegment.end) {
+ this.state = CoarsePolymerTraceIteratorState.nextPolymer
+ }
+ }
+
+ this.hasNext = this.elementIndex + 1 < this.polymerSegment.end || this.polymerIt.hasNext
+ return this.value;
+ }
+
+ constructor(private unit: Unit.Spheres | Unit.Gaussians) {
+ this.polymerIt = SortedRanges.transientSegments(getPolymerRanges(unit), unit.elements);
+ this.value = createPolymerTraceElement(unit)
+ switch (unit.kind) {
+ case Unit.Kind.Spheres: this.conformation = unit.model.coarseConformation.spheres; break
+ case Unit.Kind.Gaussians: this.conformation = unit.model.coarseConformation.gaussians; break
+ }
+ this.hasNext = this.polymerIt.hasNext
+ }
+}
\ No newline at end of file