molstar/lib/extensions/rcsb/validation-report/representation.js

A comprehensive macromolecular library.

/**
 * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */
import { __assign } from "tslib";
import { ParamDefinition as PD } from '../../../mol-util/param-definition';
import { Unit, StructureElement, Bond } from '../../../mol-model/structure';
import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
import { EmptyLoci, DataLoci } from '../../../mol-model/loci';
import { Representation } from '../../../mol-repr/representation';
import { UnitsRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation } from '../../../mol-repr/structure/representation';
import { createLinkCylinderMesh, LinkCylinderParams } from '../../../mol-repr/structure/visual/util/link';
import { UnitsMeshParams, UnitsMeshVisual } from '../../../mol-repr/structure/units-visual';
import { LocationIterator } from '../../../mol-geo/util/location-iterator';
import { ClashesProvider, ValidationReport } from './prop';
import { ComplexMeshParams, ComplexMeshVisual } from '../../../mol-repr/structure/complex-visual';
import { Color } from '../../../mol-util/color';
import { MarkerActions } from '../../../mol-util/marker-action';
import { CentroidHelper } from '../../../mol-math/geometry/centroid-helper';
import { bondLabel } from '../../../mol-theme/label';
import { getUnitKindsParam } from '../../../mol-repr/structure/params';
//
function createIntraUnitClashCylinderMesh(ctx, unit, structure, theme, props, mesh) {
    if (!Unit.isAtomic(unit))
        return Mesh.createEmpty(mesh);
    var clashes = ClashesProvider.get(structure).value.intraUnit.get(unit.id);
    var edgeCount = clashes.edgeCount, a = clashes.a, b = clashes.b, edgeProps = clashes.edgeProps;
    var magnitude = edgeProps.magnitude;
    var sizeFactor = props.sizeFactor;
    if (!edgeCount)
        return Mesh.createEmpty(mesh);
    var elements = unit.elements;
    var pos = unit.conformation.invariantPosition;
    var builderProps = {
        linkCount: edgeCount * 2,
        position: function (posA, posB, edgeIndex) {
            pos(elements[a[edgeIndex]], posA);
            pos(elements[b[edgeIndex]], posB);
        },
        style: function (edgeIndex) { return 6 /* Disk */; },
        radius: function (edgeIndex) { return magnitude[edgeIndex] * sizeFactor; },
    };
    return createLinkCylinderMesh(ctx, builderProps, props, mesh);
}
export var IntraUnitClashParams = __assign(__assign(__assign({}, UnitsMeshParams), LinkCylinderParams), { linkCap: PD.Boolean(true), sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.01 }) });
export function IntraUnitClashVisual(materialId) {
    return UnitsMeshVisual({
        defaultProps: PD.getDefaultValues(IntraUnitClashParams),
        createGeometry: createIntraUnitClashCylinderMesh,
        createLocationIterator: createIntraClashIterator,
        getLoci: getIntraClashLoci,
        eachLocation: eachIntraClash,
        setUpdateState: function (state, newProps, currentProps) {
            state.createGeometry = (newProps.sizeFactor !== currentProps.sizeFactor ||
                newProps.radialSegments !== currentProps.radialSegments ||
                newProps.linkScale !== currentProps.linkScale ||
                newProps.linkSpacing !== currentProps.linkSpacing ||
                newProps.linkCap !== currentProps.linkCap);
        }
    }, materialId);
}
function getIntraClashBoundingSphere(unit, clashes, elements, boundingSphere) {
    return CentroidHelper.fromPairProvider(elements.length, function (i, pA, pB) {
        unit.conformation.position(unit.elements[clashes.a[elements[i]]], pA);
        unit.conformation.position(unit.elements[clashes.b[elements[i]]], pB);
    }, boundingSphere);
}
function getIntraClashLabel(structure, unit, clashes, elements) {
    var idx = elements[0];
    if (idx === undefined)
        return '';
    var _a = clashes.edgeProps, id = _a.id, magnitude = _a.magnitude, distance = _a.distance;
    var mag = magnitude[idx].toFixed(2);
    var dist = distance[idx].toFixed(2);
    return [
        "Clash id: " + id[idx] + " | Magnitude: " + mag + " \u212B | Distance: " + dist + " \u212B",
        bondLabel(Bond.Location(structure, unit, clashes.a[idx], structure, unit, clashes.b[idx]))
    ].join('</br>');
}
function IntraClashLoci(structure, unit, clashes, elements) {
    return DataLoci('intra-clashes', { unit: unit, clashes: clashes }, elements, function (boundingSphere) { return getIntraClashBoundingSphere(unit, clashes, elements, boundingSphere); }, function () { return getIntraClashLabel(structure, unit, clashes, elements); });
}
function getIntraClashLoci(pickingId, structureGroup, id) {
    var objectId = pickingId.objectId, instanceId = pickingId.instanceId, groupId = pickingId.groupId;
    if (id === objectId) {
        var structure = structureGroup.structure, group = structureGroup.group;
        var unit = group.units[instanceId];
        if (Unit.isAtomic(unit)) {
            var clashes = ClashesProvider.get(structure).value.intraUnit.get(unit.id);
            return IntraClashLoci(structure, unit, clashes, [groupId]);
        }
    }
    return EmptyLoci;
}
function eachIntraClash(loci, structureGroup, apply) {
    var changed = false;
    // TODO
    return changed;
}
function createIntraClashIterator(structureGroup) {
    var structure = structureGroup.structure, group = structureGroup.group;
    var unit = group.units[0];
    var clashes = ClashesProvider.get(structure).value.intraUnit.get(unit.id);
    var a = clashes.a;
    var groupCount = clashes.edgeCount * 2;
    var instanceCount = group.units.length;
    var location = StructureElement.Location.create(structure);
    var getLocation = function (groupIndex, instanceIndex) {
        var unit = group.units[instanceIndex];
        location.unit = unit;
        location.element = unit.elements[a[groupIndex]];
        return location;
    };
    return LocationIterator(groupCount, instanceCount, 1, getLocation);
}
//
function createInterUnitClashCylinderMesh(ctx, structure, theme, props, mesh) {
    var clashes = ClashesProvider.get(structure).value.interUnit;
    var edges = clashes.edges, edgeCount = clashes.edgeCount;
    var sizeFactor = props.sizeFactor;
    if (!edgeCount)
        return Mesh.createEmpty(mesh);
    var builderProps = {
        linkCount: edgeCount,
        position: function (posA, posB, edgeIndex) {
            var b = edges[edgeIndex];
            var uA = structure.unitMap.get(b.unitA);
            var uB = structure.unitMap.get(b.unitB);
            uA.conformation.position(uA.elements[b.indexA], posA);
            uB.conformation.position(uB.elements[b.indexB], posB);
        },
        style: function (edgeIndex) { return 6 /* Disk */; },
        radius: function (edgeIndex) { return edges[edgeIndex].props.magnitude * sizeFactor; }
    };
    return createLinkCylinderMesh(ctx, builderProps, props, mesh);
}
export var InterUnitClashParams = __assign(__assign(__assign({}, ComplexMeshParams), LinkCylinderParams), { linkCap: PD.Boolean(true), sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.01 }) });
export function InterUnitClashVisual(materialId) {
    return ComplexMeshVisual({
        defaultProps: PD.getDefaultValues(InterUnitClashParams),
        createGeometry: createInterUnitClashCylinderMesh,
        createLocationIterator: createInterClashIterator,
        getLoci: getInterClashLoci,
        eachLocation: eachInterClash,
        setUpdateState: function (state, newProps, currentProps) {
            state.createGeometry = (newProps.sizeFactor !== currentProps.sizeFactor ||
                newProps.radialSegments !== currentProps.radialSegments ||
                newProps.linkScale !== currentProps.linkScale ||
                newProps.linkSpacing !== currentProps.linkSpacing ||
                newProps.linkCap !== currentProps.linkCap);
        }
    }, materialId);
}
function getInterClashBoundingSphere(structure, clashes, elements, boundingSphere) {
    return CentroidHelper.fromPairProvider(elements.length, function (i, pA, pB) {
        var c = clashes.edges[elements[i]];
        var uA = structure.unitMap.get(c.unitA);
        var uB = structure.unitMap.get(c.unitB);
        uA.conformation.position(uA.elements[c.indexA], pA);
        uB.conformation.position(uB.elements[c.indexB], pB);
    }, boundingSphere);
}
function getInterClashLabel(structure, clashes, elements) {
    var idx = elements[0];
    if (idx === undefined)
        return '';
    var c = clashes.edges[idx];
    var uA = structure.unitMap.get(c.unitA);
    var uB = structure.unitMap.get(c.unitB);
    var mag = c.props.magnitude.toFixed(2);
    var dist = c.props.distance.toFixed(2);
    return [
        "Clash id: " + c.props.id + " | Magnitude: " + mag + " \u212B | Distance: " + dist + " \u212B",
        bondLabel(Bond.Location(structure, uA, c.indexA, structure, uB, c.indexB))
    ].join('</br>');
}
function InterClashLoci(structure, clashes, elements) {
    return DataLoci('inter-clashes', clashes, elements, function (boundingSphere) { return getInterClashBoundingSphere(structure, clashes, elements, boundingSphere); }, function () { return getInterClashLabel(structure, clashes, elements); });
}
function getInterClashLoci(pickingId, structure, id) {
    var objectId = pickingId.objectId, groupId = pickingId.groupId;
    if (id === objectId) {
        var clashes = ClashesProvider.get(structure).value.interUnit;
        return InterClashLoci(structure, clashes, [groupId]);
    }
    return EmptyLoci;
}
function eachInterClash(loci, structure, apply) {
    var changed = false;
    // TODO
    return changed;
}
function createInterClashIterator(structure) {
    var clashes = ClashesProvider.get(structure).value.interUnit;
    var groupCount = clashes.edgeCount;
    var instanceCount = 1;
    var location = StructureElement.Location.create(structure);
    var getLocation = function (groupIndex) {
        var clash = clashes.edges[groupIndex];
        location.unit = structure.unitMap.get(clash.unitA);
        location.element = location.unit.elements[clash.indexA];
        return location;
    };
    return LocationIterator(groupCount, instanceCount, 1, getLocation, true);
}
//
var ClashesVisuals = {
    'intra-clash': function (ctx, getParams) { return UnitsRepresentation('Intra-unit clash cylinder', ctx, getParams, IntraUnitClashVisual); },
    'inter-clash': function (ctx, getParams) { return ComplexRepresentation('Inter-unit clash cylinder', ctx, getParams, InterUnitClashVisual); },
};
export var ClashesParams = __assign(__assign(__assign({}, IntraUnitClashParams), InterUnitClashParams), { unitKinds: getUnitKindsParam(['atomic']), visuals: PD.MultiSelect(['intra-clash', 'inter-clash'], PD.objectToOptions(ClashesVisuals)) });
export function getClashesParams(ctx, structure) {
    return PD.clone(ClashesParams);
}
export function ClashesRepresentation(ctx, getParams) {
    var repr = Representation.createMulti('Clashes', ctx, getParams, StructureRepresentationStateBuilder, ClashesVisuals);
    repr.setState({ markerActions: MarkerActions.Highlighting });
    return repr;
}
export var ClashesRepresentationProvider = StructureRepresentationProvider({
    name: ValidationReport.Tag.Clashes,
    label: 'Validation Clashes',
    description: 'Displays clashes between atoms as disks. Data from wwPDB Validation Report, obtained via RCSB PDB.',
    factory: ClashesRepresentation,
    getParams: getClashesParams,
    defaultValues: PD.getDefaultValues(ClashesParams),
    defaultColorTheme: { name: 'uniform', props: { value: Color(0xFA28FF) } },
    defaultSizeTheme: { name: 'physical' },
    isApplicable: function (structure) { return structure.elementCount > 0; },
    ensureCustomProperties: {
        attach: function (ctx, structure) { return ClashesProvider.attach(ctx, structure, void 0, true); },
        detach: function (data) { return ClashesProvider.ref(data, false); }
    }
});
//# sourceMappingURL=representation.js.map