molstar 3.0.1 → 3.0.2

package/lib/commonjs/mol-model-formats/shape/ply.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Schäfer, Marco <marco.schaefer@uni-tuebingen.de>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shapeFromPly = exports.PlyShapeParams = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../mol-task");
+var color_1 = require("../../mol-util/color");
+var mesh_builder_1 = require("../../mol-geo/geometry/mesh/mesh-builder");
+var mesh_1 = require("../../mol-geo/geometry/mesh/mesh");
+var shape_1 = require("../../mol-model/shape");
+var util_1 = require("../../mol-data/util");
+var array_1 = require("../../mol-util/array");
+var db_1 = require("../../mol-data/db");
+var param_definition_1 = require("../../mol-util/param-definition");
+var names_1 = require("../../mol-util/color/names");
+var object_1 = require("../../mol-util/object");
+var string_1 = require("../../mol-util/string");
+// TODO support 'edge' element, see https://www.mathworks.com/help/vision/ug/the-ply-format.html
+// TODO support missing face element
+function createPlyShapeParams(plyFile) {
+    var vertex = plyFile && plyFile.getElement('vertex');
+    var material = plyFile && plyFile.getElement('material');
+    var defaultValues = { group: '', vRed: '', vGreen: '', vBlue: '', mRed: '', mGreen: '', mBlue: '' };
+    var groupOptions = [['', '']];
+    var colorOptions = [['', '']];
+    if (vertex) {
+        for (var i = 0, il = vertex.propertyNames.length; i < il; ++i) {
+            var name_1 = vertex.propertyNames[i];
+            var type = vertex.propertyTypes[i];
+            if (type === 'uchar' || type === 'uint8' ||
+                type === 'ushort' || type === 'uint16' ||
+                type === 'uint' || type === 'uint32' ||
+                type === 'int')
+                groupOptions.push([name_1, name_1]);
+            if (type === 'uchar' || type === 'uint8')
+                colorOptions.push([name_1, name_1]);
+        }
+        // TODO hardcoded as convenience for data provided by MegaMol
+        if (vertex.propertyNames.includes('atomid'))
+            defaultValues.group = 'atomid';
+        else if (vertex.propertyNames.includes('material_index'))
+            defaultValues.group = 'material_index';
+        if (vertex.propertyNames.includes('red'))
+            defaultValues.vRed = 'red';
+        if (vertex.propertyNames.includes('green'))
+            defaultValues.vGreen = 'green';
+        if (vertex.propertyNames.includes('blue'))
+            defaultValues.vBlue = 'blue';
+    }
+    var materialOptions = [['', '']];
+    if (material) {
+        for (var i = 0, il = material.propertyNames.length; i < il; ++i) {
+            var name_2 = material.propertyNames[i];
+            var type = material.propertyTypes[i];
+            if (type === 'uchar' || type === 'uint8')
+                materialOptions.push([name_2, name_2]);
+        }
+        if (material.propertyNames.includes('red'))
+            defaultValues.mRed = 'red';
+        if (material.propertyNames.includes('green'))
+            defaultValues.mGreen = 'green';
+        if (material.propertyNames.includes('blue'))
+            defaultValues.mBlue = 'blue';
+    }
+    var defaultColoring = defaultValues.vRed && defaultValues.vGreen && defaultValues.vBlue ? 'vertex' :
+        defaultValues.mRed && defaultValues.mGreen && defaultValues.mBlue ? 'material' : 'uniform';
+    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params), { coloring: param_definition_1.ParamDefinition.MappedStatic(defaultColoring, {
+            vertex: param_definition_1.ParamDefinition.Group({
+                red: param_definition_1.ParamDefinition.Select(defaultValues.vRed, colorOptions, { label: 'Red Property' }),
+                green: param_definition_1.ParamDefinition.Select(defaultValues.vGreen, colorOptions, { label: 'Green Property' }),
+                blue: param_definition_1.ParamDefinition.Select(defaultValues.vBlue, colorOptions, { label: 'Blue Property' }),
+            }, { isFlat: true }),
+            material: param_definition_1.ParamDefinition.Group({
+                red: param_definition_1.ParamDefinition.Select(defaultValues.mRed, materialOptions, { label: 'Red Property' }),
+                green: param_definition_1.ParamDefinition.Select(defaultValues.mGreen, materialOptions, { label: 'Green Property' }),
+                blue: param_definition_1.ParamDefinition.Select(defaultValues.mBlue, materialOptions, { label: 'Blue Property' }),
+            }, { isFlat: true }),
+            uniform: param_definition_1.ParamDefinition.Group({
+                color: param_definition_1.ParamDefinition.Color(names_1.ColorNames.grey)
+            }, { isFlat: true })
+        }), grouping: param_definition_1.ParamDefinition.MappedStatic(defaultValues.group ? 'vertex' : 'none', {
+            vertex: param_definition_1.ParamDefinition.Group({
+                group: param_definition_1.ParamDefinition.Select(defaultValues.group, groupOptions, { label: 'Group Property' }),
+            }, { isFlat: true }),
+            none: param_definition_1.ParamDefinition.Group({})
+        }) });
+}
+exports.PlyShapeParams = createPlyShapeParams();
+function addVerticesRange(begI, endI, state, vertex, groupIds) {
+    var vertices = state.vertices, normals = state.normals, groups = state.groups;
+    var x = vertex.getProperty('x');
+    var y = vertex.getProperty('y');
+    var z = vertex.getProperty('z');
+    if (!x || !y || !z)
+        throw new Error('missing coordinate properties');
+    var nx = vertex.getProperty('nx');
+    var ny = vertex.getProperty('ny');
+    var nz = vertex.getProperty('nz');
+    var hasNormals = !!nx && !!ny && !!nz;
+    for (var i = begI; i < endI; ++i) {
+        util_1.ChunkedArray.add3(vertices, x.value(i), y.value(i), z.value(i));
+        if (hasNormals)
+            util_1.ChunkedArray.add3(normals, nx.value(i), ny.value(i), nz.value(i));
+        util_1.ChunkedArray.add(groups, groupIds[i]);
+    }
+}
+function addFacesRange(begI, endI, state, face) {
+    var indices = state.indices;
+    for (var i = begI; i < endI; ++i) {
+        var _a = face.value(i), entries = _a.entries, count = _a.count;
+        if (count === 3) {
+            // triangle
+            util_1.ChunkedArray.add3(indices, entries[0], entries[1], entries[2]);
+        }
+        else if (count === 4) {
+            // quadrilateral
+            util_1.ChunkedArray.add3(indices, entries[2], entries[1], entries[0]);
+            util_1.ChunkedArray.add3(indices, entries[2], entries[0], entries[3]);
+        }
+    }
+}
+function getMesh(ctx, vertex, face, groupIds, mesh) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var builderState, x, y, z, nx, ny, nz, hasNormals, updateChunk, i, il, i, il, m;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    builderState = mesh_builder_1.MeshBuilder.createState(vertex.rowCount, vertex.rowCount / 4, mesh);
+                    x = vertex.getProperty('x');
+                    y = vertex.getProperty('y');
+                    z = vertex.getProperty('z');
+                    if (!x || !y || !z)
+                        throw new Error('missing coordinate properties');
+                    nx = vertex.getProperty('nx');
+                    ny = vertex.getProperty('ny');
+                    nz = vertex.getProperty('nz');
+                    hasNormals = !!nx && !!ny && !!nz;
+                    updateChunk = 100000;
+                    i = 0, il = vertex.rowCount;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < il)) return [3 /*break*/, 4];
+                    addVerticesRange(i, Math.min(i + updateChunk, il), builderState, vertex, groupIds);
+                    if (!ctx.shouldUpdate) return [3 /*break*/, 3];
+                    return [4 /*yield*/, ctx.update({ message: 'adding ply mesh vertices', current: i, max: il })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i += updateChunk;
+                    return [3 /*break*/, 1];
+                case 4:
+                    i = 0, il = face.rowCount;
+                    _a.label = 5;
+                case 5:
+                    if (!(i < il)) return [3 /*break*/, 8];
+                    addFacesRange(i, Math.min(i + updateChunk, il), builderState, face);
+                    if (!ctx.shouldUpdate) return [3 /*break*/, 7];
+                    return [4 /*yield*/, ctx.update({ message: 'adding ply mesh faces', current: i, max: il })];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7:
+                    i += updateChunk;
+                    return [3 /*break*/, 5];
+                case 8:
+                    m = mesh_builder_1.MeshBuilder.getMesh(builderState);
+                    if (!hasNormals)
+                        mesh_1.Mesh.computeNormals(m);
+                    return [2 /*return*/, m];
+            }
+        });
+    });
+}
+var int = db_1.Column.Schema.int;
+function getGrouping(vertex, props) {
+    var grouping = props.grouping;
+    var rowCount = vertex.rowCount;
+    var column = grouping.name === 'vertex' ? vertex.getProperty(grouping.params.group) : undefined;
+    var label = grouping.name === 'vertex' ? (0, string_1.stringToWords)(grouping.params.group) : 'Vertex';
+    var ids = column ? column.toArray({ array: Uint32Array }) : (0, array_1.fillSerial)(new Uint32Array(rowCount));
+    var maxId = column ? (0, array_1.arrayMax)(ids) : rowCount - 1; // assumes uint ids
+    var map = new Uint32Array(maxId + 1);
+    for (var i = 0, il = ids.length; i < il; ++i)
+        map[ids[i]] = i;
+    return { ids: ids, map: map, label: label };
+}
+function getColoring(vertex, material, props) {
+    var coloring = props.coloring;
+    var rowCount = vertex.rowCount;
+    var red, green, blue;
+    if (coloring.name === 'vertex') {
+        red = vertex.getProperty(coloring.params.red) || db_1.Column.ofConst(127, rowCount, int);
+        green = vertex.getProperty(coloring.params.green) || db_1.Column.ofConst(127, rowCount, int);
+        blue = vertex.getProperty(coloring.params.blue) || db_1.Column.ofConst(127, rowCount, int);
+    }
+    else if (coloring.name === 'material') {
+        red = (material && material.getProperty(coloring.params.red)) || db_1.Column.ofConst(127, rowCount, int);
+        green = (material && material.getProperty(coloring.params.green)) || db_1.Column.ofConst(127, rowCount, int);
+        blue = (material && material.getProperty(coloring.params.blue)) || db_1.Column.ofConst(127, rowCount, int);
+    }
+    else {
+        var _a = color_1.Color.toRgb(coloring.params.color), r = _a[0], g = _a[1], b = _a[2];
+        red = db_1.Column.ofConst(r, rowCount, int);
+        green = db_1.Column.ofConst(g, rowCount, int);
+        blue = db_1.Column.ofConst(b, rowCount, int);
+    }
+    return { kind: coloring.name, red: red, green: green, blue: blue };
+}
+function createShape(plyFile, mesh, coloring, grouping) {
+    var kind = coloring.kind, red = coloring.red, green = coloring.green, blue = coloring.blue;
+    var ids = grouping.ids, map = grouping.map, label = grouping.label;
+    return shape_1.Shape.create('ply-mesh', plyFile, mesh, function (groupId) {
+        var idx = kind === 'material' ? groupId : map[groupId];
+        return color_1.Color.fromRgb(red.value(idx), green.value(idx), blue.value(idx));
+    }, function () { return 1; }, // size: constant
+    function (groupId) {
+        return "".concat(label, " ").concat(ids[groupId]);
+    });
+}
+function makeShapeGetter() {
+    var _this = this;
+    var _plyFile;
+    var _props;
+    var _shape;
+    var _mesh;
+    var _coloring;
+    var _grouping;
+    var getShape = function (ctx, plyFile, props, shape) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+        var vertex, face, material, newMesh, newColor;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    vertex = plyFile.getElement('vertex');
+                    if (!vertex)
+                        throw new Error('missing vertex element');
+                    face = plyFile.getElement('face');
+                    if (!face)
+                        throw new Error('missing face element');
+                    material = plyFile.getElement('material');
+                    newMesh = false;
+                    newColor = false;
+                    if (!_plyFile || _plyFile !== plyFile) {
+                        newMesh = true;
+                    }
+                    if (!_props || !param_definition_1.ParamDefinition.isParamEqual(exports.PlyShapeParams.grouping, _props.grouping, props.grouping)) {
+                        newMesh = true;
+                    }
+                    if (!_props || !param_definition_1.ParamDefinition.isParamEqual(exports.PlyShapeParams.coloring, _props.coloring, props.coloring)) {
+                        newColor = true;
+                    }
+                    if (!newMesh) return [3 /*break*/, 2];
+                    _coloring = getColoring(vertex, material, props);
+                    _grouping = getGrouping(vertex, props);
+                    return [4 /*yield*/, getMesh(ctx, vertex, face, _grouping.ids, shape && shape.geometry)];
+                case 1:
+                    _mesh = _a.sent();
+                    _shape = createShape(plyFile, _mesh, _coloring, _grouping);
+                    return [3 /*break*/, 3];
+                case 2:
+                    if (newColor) {
+                        _coloring = getColoring(vertex, material, props);
+                        _shape = createShape(plyFile, _mesh, _coloring, _grouping);
+                    }
+                    _a.label = 3;
+                case 3:
+                    _plyFile = plyFile;
+                    _props = (0, object_1.deepClone)(props);
+                    return [2 /*return*/, _shape];
+            }
+        });
+    }); };
+    return getShape;
+}
+function shapeFromPly(source, params) {
+    var _this = this;
+    return mol_task_1.Task.create('Shape Provider', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+        return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/, {
+                    label: 'Mesh',
+                    data: source,
+                    params: createPlyShapeParams(source),
+                    getShape: makeShapeGetter(),
+                    geometryUtils: mesh_1.Mesh.Utils
+                }];
+        });
+    }); });
+}
+exports.shapeFromPly = shapeFromPly;
+//# sourceMappingURL=ply.js.map

package/lib/commonjs/mol-model-formats/structure/basic/atomic.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAtomicHierarchyAndConformation = void 0;
+var tslib_1 = require("tslib");
+var db_1 = require("../../../mol-data/db");
+var int_1 = require("../../../mol-data/int");
+var schema_1 = require("../../../mol-io/reader/cif/schema");
+var geometry_1 = require("../../../mol-math/geometry");
+var linear_algebra_1 = require("../../../mol-math/linear-algebra");
+var atom_site_operator_mapping_1 = require("../../../mol-model/structure/export/categories/atom_site_operator_mapping");
+var atomic_1 = require("../../../mol-model/structure/model/properties/atomic");
+var atomic_derived_1 = require("../../../mol-model/structure/model/properties/utils/atomic-derived");
+var atomic_index_1 = require("../../../mol-model/structure/model/properties/utils/atomic-index");
+var types_1 = require("../../../mol-model/structure/model/types");
+var uuid_1 = require("../../../mol-util/uuid");
+var mmcif_1 = require("../mmcif");
+function findHierarchyOffsets(atom_site) {
+    if (atom_site._rowCount === 0)
+        return { residues: [], chains: [] };
+    var start = 0, end = atom_site._rowCount;
+    var residues = [start], chains = [start];
+    var label_entity_id = atom_site.label_entity_id, label_asym_id = atom_site.label_asym_id, label_seq_id = atom_site.label_seq_id, auth_seq_id = atom_site.auth_seq_id, pdbx_PDB_ins_code = atom_site.pdbx_PDB_ins_code;
+    for (var i = start + 1; i < end; i++) {
+        var newChain = !label_entity_id.areValuesEqual(i - 1, i) || !label_asym_id.areValuesEqual(i - 1, i);
+        var newResidue = newChain
+            || !label_seq_id.areValuesEqual(i - 1, i)
+            || !auth_seq_id.areValuesEqual(i - 1, i)
+            || !pdbx_PDB_ins_code.areValuesEqual(i - 1, i);
+        // not checking label_comp_id to allow for MICROHETEROGENEITY
+        if (newResidue)
+            residues[residues.length] = i;
+        if (newChain)
+            chains[chains.length] = i;
+    }
+    return { residues: residues, chains: chains };
+}
+function substUndefinedColumn(table, a, b) {
+    if (!table[a].isDefined) {
+        table[a] = table[b];
+    }
+    if (!table[b].isDefined) {
+        table[b] = table[a];
+    }
+}
+function createHierarchyData(atom_site, sourceIndex, offsets) {
+    var atoms = db_1.Table.ofColumns(atomic_1.AtomsSchema, {
+        type_symbol: db_1.Column.ofArray({ array: db_1.Column.mapToArray(atom_site.type_symbol, types_1.ElementSymbol), schema: db_1.Column.Schema.Aliased(db_1.Column.Schema.str) }),
+        label_atom_id: atom_site.label_atom_id,
+        auth_atom_id: atom_site.auth_atom_id,
+        label_alt_id: atom_site.label_alt_id,
+        label_comp_id: atom_site.label_comp_id,
+        auth_comp_id: atom_site.auth_comp_id,
+        pdbx_formal_charge: atom_site.pdbx_formal_charge
+    });
+    var residues = db_1.Table.view(atom_site, atomic_1.ResiduesSchema, offsets.residues);
+    var chains = db_1.Table.view(atom_site, atomic_1.ChainsSchema, offsets.chains);
+    if (!residues.label_seq_id.isDefined) {
+        var seqIds = new Int32Array(residues.label_seq_id.rowCount);
+        var residueOffsets = offsets.residues, chainOffsets = offsets.chains;
+        var cI = 0;
+        var seqId = 0;
+        for (var i = 0, il = seqIds.length; i < il; ++i) {
+            if (residueOffsets[i] >= chainOffsets[cI + 1]) {
+                cI += 1;
+                seqId = 0;
+            }
+            seqIds[i] = ++seqId; // start id on one
+        }
+        residues.label_seq_id = db_1.Column.ofIntArray(seqIds);
+    }
+    // Optimize the numeric columns
+    db_1.Table.columnToArray(residues, 'label_seq_id', Int32Array);
+    db_1.Table.columnToArray(residues, 'auth_seq_id', Int32Array);
+    // Fix possibly missing auth_/label_ columns
+    substUndefinedColumn(atoms, 'label_atom_id', 'auth_atom_id');
+    substUndefinedColumn(atoms, 'label_comp_id', 'auth_comp_id');
+    substUndefinedColumn(residues, 'label_seq_id', 'auth_seq_id');
+    substUndefinedColumn(chains, 'label_asym_id', 'auth_asym_id');
+    return { atoms: atoms, residues: residues, chains: chains, atomSourceIndex: sourceIndex };
+}
+function getConformation(atom_site) {
+    return {
+        id: uuid_1.UUID.create22(),
+        atomId: atom_site.id,
+        occupancy: atom_site.occupancy.isDefined ? atom_site.occupancy : db_1.Column.ofConst(1, atom_site._rowCount, db_1.Column.Schema.float),
+        B_iso_or_equiv: atom_site.B_iso_or_equiv,
+        xyzDefined: atom_site.Cartn_x.isDefined && atom_site.Cartn_y.isDefined && atom_site.Cartn_z.isDefined,
+        x: atom_site.Cartn_x.toArray({ array: Float32Array }),
+        y: atom_site.Cartn_y.toArray({ array: Float32Array }),
+        z: atom_site.Cartn_z.toArray({ array: Float32Array }),
+    };
+}
+function isHierarchyDataEqual(a, b) {
+    return db_1.Table.areEqual(a.chains, b.chains)
+        && db_1.Table.areEqual(a.residues, b.residues)
+        && db_1.Table.areEqual(a.atoms, b.atoms);
+}
+function createChainOperatorMappingAndSubstituteNames(hierarchy, format) {
+    var mapping = new Map();
+    if (!mmcif_1.MmcifFormat.is(format))
+        return mapping;
+    var entries = (0, schema_1.toDatabase)(atom_site_operator_mapping_1.AtomSiteOperatorMappingSchema, format.data.frame).molstar_atom_site_operator_mapping;
+    if (entries._rowCount === 0)
+        return mapping;
+    var labelMap = new Map();
+    var authMap = new Map();
+    for (var i = 0; i < entries._rowCount; i++) {
+        var assembly = entries.assembly_operator_id.valueKind(i) === 0 /* Present */
+            ? { id: entries.assembly_id.value(i), operList: [], operId: entries.assembly_operator_id.value(i) }
+            : void 0;
+        var operator = geometry_1.SymmetryOperator.create(entries.operator_name.value(i), linear_algebra_1.Mat4.identity(), {
+            assembly: assembly,
+            spgrOp: entries.symmetry_operator_index.valueKind(i) === 0 /* Present */ ? entries.symmetry_operator_index.value(i) : void 0,
+            hkl: linear_algebra_1.Vec3.ofArray(entries.symmetry_hkl.value(i)),
+            ncsId: entries.ncs_id.value(i)
+        });
+        var suffix = entries.suffix.value(i);
+        var label = entries.label_asym_id.value(i);
+        labelMap.set("".concat(label).concat(suffix), { name: label, operator: operator });
+        var auth = entries.auth_asym_id.value(i);
+        authMap.set("".concat(auth).concat(suffix), auth);
+    }
+    var _a = hierarchy.chains, label_asym_id = _a.label_asym_id, auth_asym_id = _a.auth_asym_id;
+    var mappedLabel = new Array(label_asym_id.rowCount);
+    var mappedAuth = new Array(label_asym_id.rowCount);
+    for (var i = 0; i < label_asym_id.rowCount; i++) {
+        var label = label_asym_id.value(i), auth = auth_asym_id.value(i);
+        if (!labelMap.has(label)) {
+            mappedLabel[i] = label;
+            mappedAuth[i] = auth;
+            continue;
+        }
+        var _b = labelMap.get(label), name_1 = _b.name, operator = _b.operator;
+        mapping.set(i, operator);
+        mappedLabel[i] = name_1;
+        mappedAuth[i] = authMap.get(auth) || auth;
+    }
+    hierarchy.chains.label_asym_id = db_1.Column.ofArray({ array: mappedLabel, valueKind: hierarchy.chains.label_asym_id.valueKind, schema: hierarchy.chains.label_asym_id.schema });
+    hierarchy.chains.auth_asym_id = db_1.Column.ofArray({ array: mappedAuth, valueKind: hierarchy.chains.auth_asym_id.valueKind, schema: hierarchy.chains.auth_asym_id.schema });
+    return mapping;
+}
+function getAtomicHierarchy(atom_site, sourceIndex, entities, chemicalComponentMap, format, previous) {
+    var hierarchyOffsets = findHierarchyOffsets(atom_site);
+    var hierarchyData = createHierarchyData(atom_site, sourceIndex, hierarchyOffsets);
+    var chainOperatorMapping = createChainOperatorMappingAndSubstituteNames(hierarchyData, format);
+    if (previous && isHierarchyDataEqual(previous.atomicHierarchy, hierarchyData)) {
+        return {
+            sameAsPrevious: true,
+            hierarchy: previous.atomicHierarchy,
+            chainOperatorMapping: chainOperatorMapping
+        };
+    }
+    var hierarchySegments = {
+        residueAtomSegments: int_1.Segmentation.ofOffsets(hierarchyOffsets.residues, int_1.Interval.ofBounds(0, atom_site._rowCount)),
+        chainAtomSegments: int_1.Segmentation.ofOffsets(hierarchyOffsets.chains, int_1.Interval.ofBounds(0, atom_site._rowCount)),
+    };
+    var index = (0, atomic_index_1.getAtomicIndex)(hierarchyData, entities, hierarchySegments);
+    var derived = (0, atomic_derived_1.getAtomicDerivedData)(hierarchyData, hierarchySegments, index, chemicalComponentMap);
+    var hierarchy = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, hierarchyData), hierarchySegments), { index: index, derived: derived });
+    return { sameAsPrevious: false, hierarchy: hierarchy, chainOperatorMapping: chainOperatorMapping };
+}
+function getAtomicHierarchyAndConformation(atom_site, sourceIndex, entities, chemicalComponentMap, format, previous) {
+    var _a = getAtomicHierarchy(atom_site, sourceIndex, entities, chemicalComponentMap, format, previous), sameAsPrevious = _a.sameAsPrevious, hierarchy = _a.hierarchy, chainOperatorMapping = _a.chainOperatorMapping;
+    var conformation = getConformation(atom_site);
+    return { sameAsPrevious: sameAsPrevious, hierarchy: hierarchy, conformation: conformation, chainOperatorMapping: chainOperatorMapping };
+}
+exports.getAtomicHierarchyAndConformation = getAtomicHierarchyAndConformation;
+//# sourceMappingURL=atomic.js.map

package/lib/commonjs/mol-model-formats/structure/basic/coarse.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCoarse = exports.EmptyCoarse = void 0;
+var tslib_1 = require("tslib");
+var coarse_1 = require("../../../mol-model/structure/model/properties/coarse");
+var coarse_keys_1 = require("../../../mol-model/structure/model/properties/utils/coarse-keys");
+var mol_util_1 = require("../../../mol-util");
+var int_1 = require("../../../mol-data/int");
+var linear_algebra_1 = require("../../../mol-math/linear-algebra");
+var coarse_ranges_1 = require("../../../mol-model/structure/model/properties/utils/coarse-ranges");
+var schema_1 = require("./schema");
+exports.EmptyCoarse = { hierarchy: coarse_1.CoarseHierarchy.Empty, conformation: void 0 };
+function getCoarse(data, chemicalComponentMap) {
+    var ihm_sphere_obj_site = data.ihm_sphere_obj_site, ihm_gaussian_obj_site = data.ihm_gaussian_obj_site;
+    if (ihm_sphere_obj_site._rowCount === 0 && ihm_gaussian_obj_site._rowCount === 0)
+        return exports.EmptyCoarse;
+    var sphereData = getData(ihm_sphere_obj_site);
+    var sphereConformation = getSphereConformation(ihm_sphere_obj_site);
+    var sphereKeys = (0, coarse_keys_1.getCoarseKeys)(sphereData, data.entities);
+    var sphereRanges = (0, coarse_ranges_1.getCoarseRanges)(sphereData, chemicalComponentMap);
+    var gaussianData = getData(ihm_gaussian_obj_site);
+    var gaussianConformation = getGaussianConformation(ihm_gaussian_obj_site);
+    var gaussianKeys = (0, coarse_keys_1.getCoarseKeys)(gaussianData, data.entities);
+    var gaussianRanges = (0, coarse_ranges_1.getCoarseRanges)(gaussianData, chemicalComponentMap);
+    return {
+        hierarchy: {
+            isDefined: true,
+            spheres: (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, sphereData), sphereKeys), sphereRanges),
+            gaussians: (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, gaussianData), gaussianKeys), gaussianRanges),
+        },
+        conformation: {
+            id: mol_util_1.UUID.create22(),
+            spheres: sphereConformation,
+            gaussians: gaussianConformation
+        }
+    };
+}
+exports.getCoarse = getCoarse;
+function getSphereConformation(data) {
+    return {
+        x: data.Cartn_x.toArray({ array: Float32Array }),
+        y: data.Cartn_y.toArray({ array: Float32Array }),
+        z: data.Cartn_z.toArray({ array: Float32Array }),
+        radius: data.object_radius.toArray({ array: Float32Array }),
+        rmsf: data.rmsf.toArray({ array: Float32Array })
+    };
+}
+function getGaussianConformation(data) {
+    var matrix_space = schema_1.BasicSchema.ihm_gaussian_obj_site.covariance_matrix.space;
+    var covariance_matrix = [];
+    var cm = data.covariance_matrix;
+    for (var i = 0, _i = cm.rowCount; i < _i; i++) {
+        covariance_matrix[i] = linear_algebra_1.Tensor.toMat3((0, linear_algebra_1.Mat3)(), matrix_space, cm.value(i));
+    }
+    return {
+        x: data.mean_Cartn_x.toArray({ array: Float32Array }),
+        y: data.mean_Cartn_y.toArray({ array: Float32Array }),
+        z: data.mean_Cartn_z.toArray({ array: Float32Array }),
+        weight: data.weight.toArray({ array: Float32Array }),
+        covariance_matrix: covariance_matrix
+    };
+}
+function getSegments(asym_id, seq_id_begin, seq_id_end) {
+    var chainOffsets = [0];
+    for (var i = 1, _i = asym_id.rowCount; i < _i; i++) {
+        var newChain = !asym_id.areValuesEqual(i - 1, i);
+        if (newChain)
+            chainOffsets[chainOffsets.length] = i;
+    }
+    return {
+        chainElementSegments: int_1.Segmentation.ofOffsets(chainOffsets, int_1.Interval.ofBounds(0, asym_id.rowCount))
+    };
+}
+function getData(data) {
+    var entity_id = data.entity_id, seq_id_begin = data.seq_id_begin, seq_id_end = data.seq_id_end, asym_id = data.asym_id;
+    return (0, tslib_1.__assign)({ count: entity_id.rowCount, entity_id: entity_id, asym_id: asym_id, seq_id_begin: seq_id_begin, seq_id_end: seq_id_end }, getSegments(asym_id, seq_id_begin, seq_id_end));
+}
+//# sourceMappingURL=coarse.js.map