src/geometry/helixbundle.js

/**
 * @file Helixbundle
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 * @private
 */

import { Vector3 } from '../../lib/three.es6.js'

import { ColormakerRegistry } from '../globals.js'
import { AtomPicker } from '../utils/picker.js'
import RadiusFactory from '../utils/radius-factory.js'
import Helixorient from './helixorient.js'
import { calculateMeanVector3, projectPointOnVector } from '../math/vector-utils.js'

function Helixbundle (polymer) {
  this.polymer = polymer

  this.helixorient = new Helixorient(polymer)
  this.position = this.helixorient.getPosition()
}

Helixbundle.prototype = {

  constructor: Helixbundle,

  getAxis: function (localAngle, centerDist, ssBorder, colorParams, radius, scale) {
    localAngle = localAngle || 30
    centerDist = centerDist || 2.5
    ssBorder = ssBorder === undefined ? false : ssBorder

    var polymer = this.polymer
    var structure = polymer.structure
    var n = polymer.residueCount
    var residueIndexStart = polymer.residueIndexStart

    var pos = this.position

    var cp = colorParams || {}
    cp.structure = structure

    var colormaker = ColormakerRegistry.getScheme(cp)

    var radiusFactory = new RadiusFactory(radius, scale)

    var j = 0
    var k = 0

    var axis = []
    var center = []
    var beg = []
    var end = []
    var col = []
    var pick = []
    var size = []
    var residueOffset = []
    var residueCount = []

    var tmpAxis = []
    var tmpCenter = []

    var _axis, _center
    var _beg = new Vector3()
    var _end = new Vector3()

    var rp1 = structure.getResidueProxy()
    var rp2 = structure.getResidueProxy()
    var ap = structure.getAtomProxy()

    var c1 = new Vector3()
    var c2 = new Vector3()

    var split = false

    for (var i = 0; i < n; ++i) {
      rp1.index = residueIndexStart + i
      c1.fromArray(pos.center, i * 3)

      if (i === n - 1) {
        split = true
      } else {
        rp2.index = residueIndexStart + i + 1
        c2.fromArray(pos.center, i * 3 + 3)

        if (ssBorder && rp1.sstruc !== rp2.sstruc) {
          split = true
        } else if (c1.distanceTo(c2) > centerDist) {
          split = true
        } else if (pos.bending[ i ] > localAngle) {
          split = true
        }
      }

      if (split) {
        if (i - j < 4) {
          j = i
          split = false
          continue
        }

        ap.index = rp1.traceAtomIndex

                // ignore first and last axis
        tmpAxis = pos.axis.subarray(j * 3 + 3, i * 3)
        tmpCenter = pos.center.subarray(j * 3, i * 3 + 3)

        _axis = calculateMeanVector3(tmpAxis).normalize()
        _center = calculateMeanVector3(tmpCenter)

        _beg.fromArray(tmpCenter)
        projectPointOnVector(_beg, _axis, _center)

        _end.fromArray(tmpCenter, tmpCenter.length - 3)
        projectPointOnVector(_end, _axis, _center)

        _axis.subVectors(_end, _beg)

        _axis.toArray(axis, k)
        _center.toArray(center, k)
        _beg.toArray(beg, k)
        _end.toArray(end, k)

        colormaker.atomColorToArray(ap, col, k)

        pick.push(ap.index)

        size.push(radiusFactory.atomRadius(ap))

        residueOffset.push(residueIndexStart + j)
        residueCount.push(residueIndexStart + i + 1 - j)

        k += 3
        j = i
        split = false
      }
    }

    var picking = new Float32Array(pick)

    return {
      'axis': new Float32Array(axis),
      'center': new Float32Array(center),
      'begin': new Float32Array(beg),
      'end': new Float32Array(end),
      'color': new Float32Array(col),
      'picking': new AtomPicker(picking, structure),
      'size': new Float32Array(size),
      'residueOffset': residueOffset,
      'residueCount': residueCount
    }
  }

}

export default Helixbundle