molstar
Version:
A comprehensive macromolecular library.
191 lines • 8.57 kB
JavaScript
/**
* Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __assign } from "tslib";
import { ChunkedArray } from '../../../mol-data/util';
import { GridLookup3D } from '../../../mol-math/geometry';
import { OrderedSet, SortedArray } from '../../../mol-data/int';
import { ValenceModelProvider } from '../valence-model';
import { Vec3 } from '../../../mol-math/linear-algebra';
import { getBoundary } from '../../../mol-math/geometry/boundary';
export { Features };
var Features;
(function (Features) {
function setPosition(out, unit, index, features) {
Vec3.set(out, features.x[index], features.y[index], features.z[index]);
Vec3.transformMat4(out, out, unit.conformation.operator.matrix);
return out;
}
Features.setPosition = setPosition;
function createElementsIndex(data, elementsCount) {
var offsets = new Int32Array(elementsCount + 1);
var bucketFill = new Int32Array(elementsCount);
var bucketSizes = new Int32Array(elementsCount);
var members = data.members, count = data.count, featureOffsets = data.offsets;
for (var i = 0, il = featureOffsets[count]; i < il; ++i)
++bucketSizes[members[i]];
var offset = 0;
for (var i = 0; i < elementsCount; i++) {
offsets[i] = offset;
offset += bucketSizes[i];
}
offsets[elementsCount] = offset;
var indices = new Int32Array(offset);
for (var i = 0; i < count; ++i) {
for (var j = featureOffsets[i], jl = featureOffsets[i + 1]; j < jl; ++j) {
var a = members[j];
var oa = offsets[a] + bucketFill[a];
indices[oa] = i;
++bucketFill[a];
}
}
return { indices: indices, offsets: offsets };
}
Features.createElementsIndex = createElementsIndex;
function create(elementsCount, data) {
var lookup3d;
var elementsIndex;
return __assign(__assign({}, data), { get lookup3d() {
if (!lookup3d) {
var position_1 = { x: data.x, y: data.y, z: data.z, indices: OrderedSet.ofBounds(0, data.count) };
lookup3d = GridLookup3D(position_1, getBoundary(position_1));
}
return lookup3d;
},
get elementsIndex() {
return elementsIndex || (elementsIndex = createElementsIndex(data, elementsCount));
}, subset: function (types) { return createSubset(data, types); } });
}
Features.create = create;
function createSubset(data, types) {
var lookup3d;
var count = data.count, _types = data.types;
var _indices = [];
for (var i = 0; i < count; ++i) {
if (types.has(_types[i]))
_indices.push(i);
}
var indices = SortedArray.ofSortedArray(_indices);
return {
indices: indices,
get lookup3d() {
if (!lookup3d) {
var position_2 = { x: data.x, y: data.y, z: data.z, indices: indices };
lookup3d = GridLookup3D(position_2, getBoundary(position_2));
}
return lookup3d;
}
};
}
Features.createSubset = createSubset;
function Info(structure, unit, features) {
var valenceModel = ValenceModelProvider.get(structure).value;
if (!valenceModel || !valenceModel.has(unit.id))
throw new Error('valence model required');
return {
unit: unit,
types: features.types,
feature: -1,
x: features.x,
y: features.y,
z: features.z,
members: features.members,
offsets: features.offsets,
idealGeometry: valenceModel.get(unit.id).idealGeometry
};
}
Features.Info = Info;
function position(out, info) {
Vec3.set(out, info.x[info.feature], info.y[info.feature], info.z[info.feature]);
Vec3.transformMat4(out, out, info.unit.conformation.operator.matrix);
return out;
}
Features.position = position;
var tmpVecA = Vec3();
var tmpVecB = Vec3();
function distance(infoA, infoB) {
var elementA = infoA.members[infoA.offsets[infoA.feature]];
var elementB = infoB.members[infoB.offsets[infoB.feature]];
infoA.unit.conformation.position(infoA.unit.elements[elementA], tmpVecA);
infoB.unit.conformation.position(infoB.unit.elements[elementB], tmpVecB);
return Vec3.distance(tmpVecA, tmpVecB);
}
Features.distance = distance;
function Provider(types, add) {
return { types: new Set(types), add: add };
}
Features.Provider = Provider;
})(Features || (Features = {}));
export { FeaturesBuilder };
var FeaturesBuilder;
(function (FeaturesBuilder) {
function create(initialCount, chunkSize, features) {
if (initialCount === void 0) { initialCount = 2048; }
if (chunkSize === void 0) { chunkSize = 1024; }
var xCenters = ChunkedArray.create(Float32Array, 1, chunkSize, features ? features.x : initialCount);
var yCenters = ChunkedArray.create(Float32Array, 1, chunkSize, features ? features.y : initialCount);
var zCenters = ChunkedArray.create(Float32Array, 1, chunkSize, features ? features.z : initialCount);
var types = ChunkedArray.create(Uint8Array, 1, chunkSize, features ? features.types : initialCount);
var groups = ChunkedArray.create(Uint8Array, 1, chunkSize, features ? features.groups : initialCount);
var offsets = ChunkedArray.create(Uint32Array, 1, chunkSize, features ? features.offsets : initialCount);
var members = ChunkedArray.create(Uint32Array, 1, chunkSize, features ? features.members : initialCount);
var state = { x: 0, y: 0, z: 0, offset: 0, count: 0 };
return {
startState: function () {
state.x = 0;
state.y = 0;
state.z = 0;
state.offset = members.elementCount;
state.count = 0;
},
pushMember: function (x, y, z, member) {
ChunkedArray.add(members, member);
state.x += x;
state.y += y;
state.z += z;
state.count += 1;
},
finishState: function (type, group) {
var count = state.count;
if (count === 0)
return;
ChunkedArray.add(types, type);
ChunkedArray.add(groups, group);
ChunkedArray.add(xCenters, state.x / count);
ChunkedArray.add(yCenters, state.y / count);
ChunkedArray.add(zCenters, state.z / count);
ChunkedArray.add(offsets, state.offset);
},
add: function (type, group, x, y, z, member) {
ChunkedArray.add(types, type);
ChunkedArray.add(groups, group);
ChunkedArray.add(xCenters, x);
ChunkedArray.add(yCenters, y);
ChunkedArray.add(zCenters, z);
ChunkedArray.add(offsets, members.elementCount);
ChunkedArray.add(members, member);
},
getFeatures: function (elementsCount) {
ChunkedArray.add(offsets, members.elementCount);
var x = ChunkedArray.compact(xCenters, true);
var y = ChunkedArray.compact(yCenters, true);
var z = ChunkedArray.compact(zCenters, true);
var count = xCenters.elementCount;
return Features.create(elementsCount, {
x: x,
y: y,
z: z,
count: count,
types: ChunkedArray.compact(types, true),
groups: ChunkedArray.compact(groups, true),
offsets: ChunkedArray.compact(offsets, true),
members: ChunkedArray.compact(members, true),
});
}
};
}
FeaturesBuilder.create = create;
})(FeaturesBuilder || (FeaturesBuilder = {}));
//# sourceMappingURL=features.js.map