molstar
Version:
A comprehensive macromolecular library.
229 lines • 10.5 kB
JavaScript
/**
* Copyright (c) 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>
*/
import { __awaiter, __extends, __generator } from "tslib";
import { TrajectoryFormatCategory } from '../../mol-plugin-state/formats/trajectory';
import { PluginStateObject as SO, PluginStateTransform } from '../../mol-plugin-state/objects';
import { PluginBehavior } from '../../mol-plugin/behavior';
import { DefaultQueryRuntimeTable } from '../../mol-script/runtime/query/base';
import { StateAction } from '../../mol-state';
import { Task } from '../../mol-task';
import { ParamDefinition } from '../../mol-util/param-definition';
import { getG3dDataBlock, getG3dHeader } from './data';
import { g3dHaplotypeQuery, G3dLabelProvider, trajectoryFromG3D, G3dSymbols, G3dInfoDataProperty } from './model';
import { StateTransforms } from '../../mol-plugin-state/transforms';
import { createStructureRepresentationParams } from '../../mol-plugin-state/helpers/structure-representation-params';
import { stringToWords } from '../../mol-util/string';
import { objectForEach } from '../../mol-util/object';
export var G3dProvider = {
label: 'G3D',
description: 'G3D',
category: TrajectoryFormatCategory,
binaryExtensions: ['g3d'],
parse: function (plugin, data) { return __awaiter(void 0, void 0, void 0, function () {
var trajectory;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, plugin.state.data.build()
.to(data)
.apply(G3DHeaderFromFile, {}, { state: { isGhost: true } })
.apply(G3DTrajectory)
.commit()];
case 1:
trajectory = _a.sent();
return [2 /*return*/, { trajectory: trajectory }];
}
});
}); },
visuals: defaultStructure
};
function defaultStructure(plugin, data) {
return __awaiter(this, void 0, void 0, function () {
var builder, model, structure, info, components, repr, _i, _a, h;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
builder = plugin.builders.structure;
return [4 /*yield*/, builder.createModel(data.trajectory)];
case 1:
model = _b.sent();
if (!model)
return [2 /*return*/];
return [4 /*yield*/, builder.createStructure(model)];
case 2:
structure = _b.sent();
info = G3dInfoDataProperty.get(model.data);
if (!info)
return [2 /*return*/];
components = plugin.build().to(structure);
repr = createStructureRepresentationParams(plugin, void 0, {
type: 'cartoon',
color: 'polymer-index',
size: 'uniform',
sizeParams: { value: 0.25 }
});
for (_i = 0, _a = info.haplotypes; _i < _a.length; _i++) {
h = _a[_i];
components
.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression: g3dHaplotypeQuery(h), label: stringToWords(h) })
.apply(StateTransforms.Representation.StructureRepresentation3D, repr);
}
return [4 /*yield*/, components.commit()];
case 3:
_b.sent();
return [2 /*return*/];
}
});
});
}
var G3dHeaderObject = /** @class */ (function (_super) {
__extends(G3dHeaderObject, _super);
function G3dHeaderObject() {
return _super !== null && _super.apply(this, arguments) || this;
}
return G3dHeaderObject;
}(SO.Create({ name: 'G3D Header', typeClass: 'Data' })));
export { G3dHeaderObject };
export var G3DHeaderFromFile = PluginStateTransform.BuiltIn({
name: 'g3d-header-from-file',
display: { name: 'G3D Header', description: 'Parse G3D Header' },
from: SO.Data.Binary,
to: G3dHeaderObject
})({
apply: function (_a, plugin) {
var _this = this;
var a = _a.a;
return Task.create('Parse G3D', function () { return __awaiter(_this, void 0, void 0, function () {
var header;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getG3dHeader(plugin, a.data)];
case 1:
header = _a.sent();
return [2 /*return*/, new G3dHeaderObject({ header: header, urlOrData: a.data, cache: {} }, { label: header.name, description: header.genome })];
}
});
}); });
}
});
export var G3DHeaderFromUrl = PluginStateTransform.BuiltIn({
name: 'g3d-header-from-url',
display: { name: 'G3D Header', description: 'Parse G3D Header' },
params: { url: ParamDefinition.Text('') },
from: SO.Root,
to: G3dHeaderObject
})({
apply: function (_a, plugin) {
var _this = this;
var params = _a.params;
return Task.create('Parse G3D', function () { return __awaiter(_this, void 0, void 0, function () {
var header;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getG3dHeader(plugin, params.url)];
case 1:
header = _a.sent();
return [2 /*return*/, new G3dHeaderObject({ header: header, urlOrData: params.url, cache: {} }, { label: header.name, description: header.genome })];
}
});
}); });
}
});
export var G3DTrajectory = PluginStateTransform.BuiltIn({
name: 'g3d-trajecotry',
display: { name: 'G3D Trajectory', description: 'Create G3D Trajectory' },
params: function (a) {
if (!a)
return { resolution: ParamDefinition.Numeric(200000) };
var rs = a.data.header.resolutions;
return {
resolution: ParamDefinition.Select(rs[rs.length - 1], rs.map(function (r) { return [r, '' + r]; }))
};
},
from: G3dHeaderObject,
to: SO.Molecule.Trajectory
})({
apply: function (_a, plugin) {
var _this = this;
var a = _a.a, params = _a.params;
return Task.create('G3D Trajectory', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
var data, traj;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (a.data.cache[params.resolution]) {
return [2 /*return*/, new SO.Molecule.Trajectory(a.data.cache[params.resolution], { label: a.label, description: a.description })];
}
return [4 /*yield*/, getG3dDataBlock(plugin, a.data.header, a.data.urlOrData, params.resolution)];
case 1:
data = _a.sent();
return [4 /*yield*/, trajectoryFromG3D(data).runInContext(ctx)];
case 2:
traj = _a.sent();
a.data.cache[params.resolution] = traj;
return [2 /*return*/, new SO.Molecule.Trajectory(traj, { label: a.label, description: a.description })];
}
});
}); });
}
});
export var LoadG3D = StateAction.build({
display: { name: 'Load Genome 3D (G3D)', description: 'Load G3D file from the specified URL.' },
from: SO.Root,
params: { url: ParamDefinition.Text('') }
})(function (_a, ctx) {
var params = _a.params, state = _a.state;
return Task.create('Genome3D', function (taskCtx) {
return state.transaction(function () { return __awaiter(void 0, void 0, void 0, function () {
var trajectory;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (params.url.trim().length === 0) {
throw new Error('Specify URL');
}
ctx.behaviors.layout.leftPanelTabName.next('data');
return [4 /*yield*/, state.build().toRoot()
.apply(G3DHeaderFromUrl, { url: params.url })
.apply(G3DTrajectory)
.commit()];
case 1:
trajectory = _a.sent();
return [4 /*yield*/, defaultStructure(ctx, { trajectory: trajectory })];
case 2:
_a.sent();
return [2 /*return*/];
}
});
}); }).runInContext(taskCtx);
});
});
export var G3DFormat = PluginBehavior.create({
name: 'g3d',
category: 'misc',
display: {
name: 'G3D',
description: 'G3D Format Support'
},
ctor: /** @class */ (function (_super) {
__extends(class_1, _super);
function class_1() {
return _super !== null && _super.apply(this, arguments) || this;
}
class_1.prototype.register = function () {
this.ctx.state.data.actions.add(LoadG3D);
objectForEach(G3dSymbols, function (s) { return DefaultQueryRuntimeTable.addSymbol(s); });
this.ctx.managers.lociLabels.addProvider(G3dLabelProvider);
};
class_1.prototype.unregister = function () {
this.ctx.state.data.actions.remove(LoadG3D);
objectForEach(G3dSymbols, function (s) { return DefaultQueryRuntimeTable.removeSymbol(s); });
this.ctx.managers.lociLabels.removeProvider(G3dLabelProvider);
};
return class_1;
}(PluginBehavior.Handler))
});
//# sourceMappingURL=format.js.map