molstar 3.26.0 → 3.28.0

package/lib/commonjs/extensions/volumes-and-segmentations/entry-segmentation.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolsegLatticeSegmentationData = void 0;
+var tslib_1 = require("tslib");
+var volume_1 = require("../../mol-model/volume");
+var volume_representation_params_1 = require("../../mol-plugin-state/helpers/volume-representation-params");
+var transforms_1 = require("../../mol-plugin-state/transforms");
+var data_1 = require("../../mol-plugin-state/transforms/data");
+var misc_1 = require("../../mol-plugin-state/transforms/misc");
+var volume_2 = require("../../mol-plugin-state/transforms/volume");
+var commands_1 = require("../../mol-plugin/commands");
+var color_1 = require("../../mol-util/color");
+var entry_root_1 = require("./entry-root");
+var global_state_1 = require("./global-state");
+var GROUP_TAG = 'lattice-segmentation-group';
+var SEGMENT_VISUAL_TAG = 'lattice-segment-visual';
+var DEFAULT_SEGMENT_COLOR = color_1.Color.fromNormalizedRgb(0.8, 0.8, 0.8);
+var VolsegLatticeSegmentationData = /** @class */ (function () {
+    function VolsegLatticeSegmentationData(rootData) {
+        this.entryData = rootData;
+    }
+    VolsegLatticeSegmentationData.prototype.loadSegmentation = function () {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hasLattices, url, group, newGroupNode, segmentLabels, volumeNode, volumeData, segmentation, segmentIds;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        hasLattices = this.entryData.metadata.raw.grid.segmentation_lattices.segmentation_lattice_ids.length > 0;
+                        if (!hasLattices) return [3 /*break*/, 5];
+                        url = this.entryData.api.latticeUrl(this.entryData.source, this.entryData.entryId, 0, entry_root_1.BOX, entry_root_1.MAX_VOXELS);
+                        group = (_a = this.entryData.findNodesByTags(GROUP_TAG)[0]) === null || _a === void 0 ? void 0 : _a.transform.ref;
+                        if (!!group) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.entryData.newUpdate().apply(misc_1.CreateGroup, { label: 'Segmentation', description: 'Lattice' }, { tags: [GROUP_TAG], state: { isCollapsed: true } }).commit()];
+                    case 1:
+                        newGroupNode = _d.sent();
+                        group = newGroupNode.ref;
+                        _d.label = 2;
+                    case 2:
+                        segmentLabels = this.entryData.metadata.allSegments.map(function (seg) { return ({ id: seg.id, label: seg.biological_annotation.name ? "<b>".concat(seg.biological_annotation.name, "</b>") : '' }); });
+                        return [4 /*yield*/, this.entryData.newUpdate().to(group)
+                                .apply(data_1.Download, { url: url, isBinary: true, label: "Segmentation Data: ".concat(url) })
+                                .apply(data_1.ParseCif)
+                                .apply(volume_2.VolumeFromSegmentationCif, { blockHeader: 'SEGMENTATION_DATA', segmentLabels: segmentLabels, ownerId: this.entryData.ref })
+                                .commit()];
+                    case 3:
+                        volumeNode = _d.sent();
+                        volumeData = volumeNode.data;
+                        segmentation = volume_1.Volume.Segmentation.get(volumeData);
+                        segmentIds = Array.from((_b = segmentation === null || segmentation === void 0 ? void 0 : segmentation.segments.keys()) !== null && _b !== void 0 ? _b : []);
+                        return [4 /*yield*/, this.entryData.newUpdate().to(volumeNode)
+                                .apply(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, (0, volume_representation_params_1.createVolumeRepresentationParams)(this.entryData.plugin, volumeData, {
+                                type: 'segment',
+                                typeParams: { tryUseGpu: (_c = global_state_1.VolsegGlobalStateData.getGlobalState(this.entryData.plugin)) === null || _c === void 0 ? void 0 : _c.tryUseGpu },
+                                color: 'volume-segment',
+                                colorParams: { palette: this.createPalette(segmentIds) },
+                            }), { tags: [SEGMENT_VISUAL_TAG] }).commit()];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegLatticeSegmentationData.prototype.createPalette = function (segmentIds) {
+        var colorMap = new Map();
+        for (var _i = 0, _a = this.entryData.metadata.allSegments; _i < _a.length; _i++) {
+            var segment = _a[_i];
+            var color = color_1.Color.fromNormalizedArray(segment.colour, 0);
+            colorMap.set(segment.id, color);
+        }
+        if (colorMap.size === 0)
+            return undefined;
+        for (var _b = 0, segmentIds_1 = segmentIds; _b < segmentIds_1.length; _b++) {
+            var segid = segmentIds_1[_b];
+            colorMap.get(segid);
+        }
+        var colors = segmentIds.map(function (segid) { var _a; return (_a = colorMap.get(segid)) !== null && _a !== void 0 ? _a : DEFAULT_SEGMENT_COLOR; });
+        return { name: 'colors', params: { list: { kind: 'set', colors: colors } } };
+    };
+    VolsegLatticeSegmentationData.prototype.updateOpacity = function (opacity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var reprs, update, _i, reprs_1, s;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reprs = this.entryData.findNodesByTags(SEGMENT_VISUAL_TAG);
+                        update = this.entryData.newUpdate();
+                        for (_i = 0, reprs_1 = reprs; _i < reprs_1.length; _i++) {
+                            s = reprs_1[_i];
+                            update.to(s).update(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, function (p) { p.type.params.alpha = opacity; });
+                        }
+                        return [4 /*yield*/, update.commit()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    VolsegLatticeSegmentationData.prototype.makeLoci = function (segments) {
+        var _a;
+        var vis = this.entryData.findNodesByTags(SEGMENT_VISUAL_TAG)[0];
+        if (!vis)
+            return undefined;
+        var repr = (_a = vis.obj) === null || _a === void 0 ? void 0 : _a.data.repr;
+        var wholeLoci = repr.getAllLoci()[0];
+        if (!wholeLoci || !volume_1.Volume.Segment.isLoci(wholeLoci))
+            return undefined;
+        return { loci: volume_1.Volume.Segment.Loci(wholeLoci.volume, segments), repr: repr };
+    };
+    VolsegLatticeSegmentationData.prototype.highlightSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var segmentLoci;
+            return tslib_1.__generator(this, function (_a) {
+                segmentLoci = this.makeLoci([segment.id]);
+                if (!segmentLoci)
+                    return [2 /*return*/];
+                this.entryData.plugin.managers.interactivity.lociHighlights.highlight(segmentLoci, false);
+                return [2 /*return*/];
+            });
+        });
+    };
+    VolsegLatticeSegmentationData.prototype.selectSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var segmentLoci;
+            return tslib_1.__generator(this, function (_a) {
+                if (segment === undefined || segment < 0)
+                    return [2 /*return*/];
+                segmentLoci = this.makeLoci([segment]);
+                if (!segmentLoci)
+                    return [2 /*return*/];
+                this.entryData.plugin.managers.interactivity.lociSelects.select(segmentLoci, false);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /** Make visible the specified set of lattice segments */
+    VolsegLatticeSegmentationData.prototype.showSegments = function (segments) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var repr, selectedSegment, mustReselect, update;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        repr = this.entryData.findNodesByTags(SEGMENT_VISUAL_TAG)[0];
+                        if (!repr)
+                            return [2 /*return*/];
+                        selectedSegment = this.entryData.currentState.value.selectedSegment;
+                        mustReselect = segments.includes(selectedSegment) && !((_a = repr.params) === null || _a === void 0 ? void 0 : _a.values.type.params.segments.includes(selectedSegment));
+                        update = this.entryData.newUpdate();
+                        update.to(repr).update(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, function (p) { p.type.params.segments = segments; });
+                        return [4 /*yield*/, update.commit()];
+                    case 1:
+                        _b.sent();
+                        if (!mustReselect) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.selectSegment(this.entryData.currentState.value.selectedSegment)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegLatticeSegmentationData.prototype.setTryUseGpu = function (tryUseGpu) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visuals, _i, visuals_1, visual, oldParams, newParams, update;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        visuals = this.entryData.findNodesByTags(SEGMENT_VISUAL_TAG);
+                        _i = 0, visuals_1 = visuals;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < visuals_1.length)) return [3 /*break*/, 4];
+                        visual = visuals_1[_i];
+                        oldParams = visual.transform.params;
+                        if (!(oldParams.type.params.tryUseGpu === !tryUseGpu)) return [3 /*break*/, 3];
+                        newParams = tslib_1.__assign(tslib_1.__assign({}, oldParams), { type: tslib_1.__assign(tslib_1.__assign({}, oldParams.type), { params: tslib_1.__assign(tslib_1.__assign({}, oldParams.type.params), { tryUseGpu: tryUseGpu }) }) });
+                        update = this.entryData.newUpdate().to(visual.transform.ref).update(newParams);
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.entryData.plugin, { state: this.entryData.plugin.state.data, tree: update, options: { doNotUpdateCurrent: true } })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return VolsegLatticeSegmentationData;
+}());
+exports.VolsegLatticeSegmentationData = VolsegLatticeSegmentationData;

package/lib/commonjs/extensions/volumes-and-segmentations/entry-state.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { Choice } from './helpers';
+export declare const VolumeTypeChoice: Choice<"off" | "direct-volume" | "isosurface", "isosurface">;
+export type VolumeType = Choice.Values<typeof VolumeTypeChoice>;
+export declare const VolsegStateParams: {
+    volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
+    volumeIsovalueKind: PD.Select<string>;
+    volumeIsovalueValue: PD.Numeric;
+    volumeOpacity: PD.Numeric;
+    segmentOpacity: PD.Numeric;
+    selectedSegment: PD.Numeric;
+    visibleSegments: PD.ObjectList<PD.Normalize<{
+        segmentId: number;
+    }>>;
+    visibleModels: PD.ObjectList<PD.Normalize<{
+        pdbId: string;
+    }>>;
+};
+export type VolsegStateData = PD.Values<typeof VolsegStateParams>;
+declare const VolsegState_base: {
+    new (data: PD.Values<{
+        volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
+        volumeIsovalueKind: PD.Select<string>;
+        volumeIsovalueValue: PD.Numeric;
+        volumeOpacity: PD.Numeric;
+        segmentOpacity: PD.Numeric;
+        selectedSegment: PD.Numeric;
+        visibleSegments: PD.ObjectList<PD.Normalize<{
+            segmentId: number;
+        }>>;
+        visibleModels: PD.ObjectList<PD.Normalize<{
+            pdbId: string;
+        }>>;
+    }>, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: PD.Values<{
+            volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
+            volumeIsovalueKind: PD.Select<string>;
+            volumeIsovalueValue: PD.Numeric;
+            volumeOpacity: PD.Numeric;
+            segmentOpacity: PD.Numeric;
+            selectedSegment: PD.Numeric;
+            visibleSegments: PD.ObjectList<PD.Normalize<{
+                segmentId: number;
+            }>>;
+            visibleModels: PD.ObjectList<PD.Normalize<{
+                pdbId: string;
+            }>>;
+        }>;
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>> | undefined): obj is {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: PD.Values<{
+            volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
+            volumeIsovalueKind: PD.Select<string>;
+            volumeIsovalueValue: PD.Numeric;
+            volumeOpacity: PD.Numeric;
+            segmentOpacity: PD.Numeric;
+            selectedSegment: PD.Numeric;
+            visibleSegments: PD.ObjectList<PD.Normalize<{
+                segmentId: number;
+            }>>;
+            visibleModels: PD.ObjectList<PD.Normalize<{
+                pdbId: string;
+            }>>;
+        }>;
+    };
+};
+export declare class VolsegState extends VolsegState_base {
+}
+export declare const VOLSEG_STATE_FROM_ENTRY_TRANSFORMER_NAME = "volseg-state-from-entry";
+export {};

package/lib/commonjs/extensions/volumes-and-segmentations/entry-state.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VOLSEG_STATE_FROM_ENTRY_TRANSFORMER_NAME = exports.VolsegState = exports.VolsegStateParams = exports.VolumeTypeChoice = void 0;
+var tslib_1 = require("tslib");
+var objects_1 = require("../../mol-plugin-state/objects");
+var param_definition_1 = require("../../mol-util/param-definition");
+var helpers_1 = require("./helpers");
+exports.VolumeTypeChoice = new helpers_1.Choice({ 'isosurface': 'Isosurface', 'direct-volume': 'Direct volume', 'off': 'Off' }, 'isosurface');
+exports.VolsegStateParams = {
+    volumeType: exports.VolumeTypeChoice.PDSelect(),
+    volumeIsovalueKind: param_definition_1.ParamDefinition.Select('relative', [['relative', 'Relative'], ['absolute', 'Absolute']]),
+    volumeIsovalueValue: param_definition_1.ParamDefinition.Numeric(1),
+    volumeOpacity: param_definition_1.ParamDefinition.Numeric(0.2, { min: 0, max: 1, step: 0.05 }),
+    segmentOpacity: param_definition_1.ParamDefinition.Numeric(1, { min: 0, max: 1, step: 0.05 }),
+    selectedSegment: param_definition_1.ParamDefinition.Numeric(-1, { step: 1 }),
+    visibleSegments: param_definition_1.ParamDefinition.ObjectList({ segmentId: param_definition_1.ParamDefinition.Numeric(0) }, function (s) { return s.segmentId.toString(); }),
+    visibleModels: param_definition_1.ParamDefinition.ObjectList({ pdbId: param_definition_1.ParamDefinition.Text('') }, function (s) { return s.pdbId.toString(); }),
+};
+var VolsegState = /** @class */ (function (_super) {
+    tslib_1.__extends(VolsegState, _super);
+    function VolsegState() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return VolsegState;
+}(objects_1.PluginStateObject.Create({ name: 'Vol & Seg Entry State', typeClass: 'Data' })));
+exports.VolsegState = VolsegState;
+exports.VOLSEG_STATE_FROM_ENTRY_TRANSFORMER_NAME = 'volseg-state-from-entry'; // defined here to avoid cyclic dependency

package/lib/commonjs/extensions/volumes-and-segmentations/entry-volume.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { createVolumeRepresentationParams } from '../../mol-plugin-state/helpers/volume-representation-params';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { VolsegEntryData } from './entry-root';
+export declare const VOLUME_VISUAL_TAG = "volume-visual";
+export type VolumeVisualParams = ReturnType<typeof createVolumeRepresentationParams>;
+export declare const SimpleVolumeParams: {
+    volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
+    opacity: PD.Numeric;
+};
+export type SimpleVolumeParamValues = PD.Values<typeof SimpleVolumeParams>;
+export declare class VolsegVolumeData {
+    private entryData;
+    private visualTypeParamCache;
+    constructor(rootData: VolsegEntryData);
+    loadVolume(): Promise<{
+        isovalue: Readonly<{
+            kind: "absolute";
+            absoluteValue: number;
+        }> | Readonly<{
+            kind: "relative";
+            relativeValue: number;
+        }>;
+    } | undefined>;
+    setVolumeVisual(type: 'isosurface' | 'direct-volume' | 'off'): Promise<void>;
+    updateVolumeVisual(newParams: SimpleVolumeParamValues): Promise<void>;
+    setTryUseGpu(tryUseGpu: boolean): Promise<void>;
+    private getIsovalueFromState;
+    private createVolumeVisualParams;
+    private changeIsovalueInVolumeVisualParams;
+}

package/lib/commonjs/extensions/volumes-and-segmentations/entry-volume.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolsegVolumeData = exports.SimpleVolumeParams = exports.VOLUME_VISUAL_TAG = void 0;
+var tslib_1 = require("tslib");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var volume_1 = require("../../mol-model/volume");
+var volume_representation_params_1 = require("../../mol-plugin-state/helpers/volume-representation-params");
+var transforms_1 = require("../../mol-plugin-state/transforms");
+var data_1 = require("../../mol-plugin-state/transforms/data");
+var misc_1 = require("../../mol-plugin-state/transforms/misc");
+var state_1 = require("../../mol-plugin/behavior/static/state");
+var commands_1 = require("../../mol-plugin/commands");
+var color_1 = require("../../mol-util/color");
+var param_definition_1 = require("../../mol-util/param-definition");
+var entry_root_1 = require("./entry-root");
+var entry_state_1 = require("./entry-state");
+var ExternalAPIs = tslib_1.__importStar(require("./external-api"));
+var global_state_1 = require("./global-state");
+var GROUP_TAG = 'volume-group';
+exports.VOLUME_VISUAL_TAG = 'volume-visual';
+var DIRECT_VOLUME_RELATIVE_PEAK_HALFWIDTH = 0.5;
+;
+exports.SimpleVolumeParams = {
+    volumeType: entry_state_1.VolumeTypeChoice.PDSelect(),
+    opacity: param_definition_1.ParamDefinition.Numeric(0.2, { min: 0, max: 1, step: 0.05 }, { hideIf: function (p) { return p.volumeType === 'off'; } }),
+};
+var VolsegVolumeData = /** @class */ (function () {
+    function VolsegVolumeData(rootData) {
+        this.visualTypeParamCache = {};
+        this.entryData = rootData;
+    }
+    VolsegVolumeData.prototype.loadVolume = function () {
+        var _a, _b, _c, _d;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hasVolumes, isoLevelPromise, group, newGroupNode, url, data, parsed, volumeNode, volumeData, volumeType, isovalue, stats, maxRelative, adjustedIsovalue, visualParams;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        hasVolumes = this.entryData.metadata.raw.grid.volumes.volume_downsamplings.length > 0;
+                        if (!hasVolumes) return [3 /*break*/, 7];
+                        isoLevelPromise = ExternalAPIs.tryGetIsovalue((_a = this.entryData.metadata.raw.grid.general.source_db_id) !== null && _a !== void 0 ? _a : this.entryData.entryId);
+                        group = (_b = this.entryData.findNodesByTags(GROUP_TAG)[0]) === null || _b === void 0 ? void 0 : _b.transform.ref;
+                        if (!!group) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.entryData.newUpdate().apply(misc_1.CreateGroup, { label: 'Volume' }, { tags: [GROUP_TAG], state: { isCollapsed: true } }).commit()];
+                    case 1:
+                        newGroupNode = _e.sent();
+                        group = newGroupNode.ref;
+                        _e.label = 2;
+                    case 2:
+                        url = this.entryData.api.volumeUrl(this.entryData.source, this.entryData.entryId, entry_root_1.BOX, entry_root_1.MAX_VOXELS);
+                        return [4 /*yield*/, this.entryData.newUpdate().to(group).apply(data_1.Download, { url: url, isBinary: true, label: "Volume Data: ".concat(url) }).commit()];
+                    case 3:
+                        data = _e.sent();
+                        return [4 /*yield*/, this.entryData.plugin.dataFormats.get('dscif').parse(this.entryData.plugin, data)];
+                    case 4:
+                        parsed = _e.sent();
+                        volumeNode = (_d = (_c = parsed.volumes) === null || _c === void 0 ? void 0 : _c[0]) !== null && _d !== void 0 ? _d : parsed.volume;
+                        volumeData = volumeNode.cell.obj.data;
+                        volumeType = entry_state_1.VolsegStateParams.volumeType.defaultValue;
+                        return [4 /*yield*/, isoLevelPromise];
+                    case 5:
+                        isovalue = _e.sent();
+                        if (!isovalue) {
+                            stats = volumeData.grid.stats;
+                            maxRelative = (stats.max - stats.mean) / stats.sigma;
+                            if (maxRelative > 1) {
+                                isovalue = { kind: 'relative', value: 1.0 };
+                            }
+                            else {
+                                isovalue = { kind: 'relative', value: maxRelative * 0.5 };
+                            }
+                        }
+                        adjustedIsovalue = volume_1.Volume.adjustedIsoValue(volumeData, isovalue.value, isovalue.kind);
+                        visualParams = this.createVolumeVisualParams(volumeData, volumeType);
+                        this.changeIsovalueInVolumeVisualParams(visualParams, adjustedIsovalue, volumeData.grid.stats);
+                        return [4 /*yield*/, this.entryData.newUpdate()
+                                .to(volumeNode)
+                                .apply(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, visualParams, { tags: [exports.VOLUME_VISUAL_TAG], state: { isHidden: volumeType === 'off' } })
+                                .commit()];
+                    case 6:
+                        _e.sent();
+                        return [2 /*return*/, { isovalue: adjustedIsovalue }];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegVolumeData.prototype.setVolumeVisual = function (type) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visual, oldParams, newParams, volumeStats, update;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        visual = this.entryData.findNodesByTags(exports.VOLUME_VISUAL_TAG)[0];
+                        if (!visual)
+                            return [2 /*return*/];
+                        oldParams = visual.transform.params;
+                        this.visualTypeParamCache[oldParams.type.name] = oldParams.type.params;
+                        if (!(type === 'off')) return [3 /*break*/, 1];
+                        (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, true); // true means hide, ¯\_(ツ)_/¯
+                        return [3 /*break*/, 3];
+                    case 1:
+                        (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, false); // true means hide, ¯\_(ツ)_/¯
+                        if (oldParams.type.name === type)
+                            return [2 /*return*/];
+                        newParams = tslib_1.__assign(tslib_1.__assign({}, oldParams), { type: {
+                                name: type,
+                                params: (_a = this.visualTypeParamCache[type]) !== null && _a !== void 0 ? _a : oldParams.type.params,
+                            } });
+                        volumeStats = (_b = visual.obj) === null || _b === void 0 ? void 0 : _b.data.sourceData.grid.stats;
+                        if (!volumeStats)
+                            throw new Error("Cannot get volume stats from volume visual ".concat(visual.transform.ref));
+                        this.changeIsovalueInVolumeVisualParams(newParams, undefined, volumeStats);
+                        update = this.entryData.newUpdate().to(visual.transform.ref).update(newParams);
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.entryData.plugin, { state: this.entryData.plugin.state.data, tree: update, options: { doNotUpdateCurrent: true } })];
+                    case 2:
+                        _c.sent();
+                        _c.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegVolumeData.prototype.updateVolumeVisual = function (newParams) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var volumeType, opacity, visual, oldVisualParams, newVisualParams, volumeStats, update;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        volumeType = newParams.volumeType, opacity = newParams.opacity;
+                        visual = this.entryData.findNodesByTags(exports.VOLUME_VISUAL_TAG)[0];
+                        if (!visual)
+                            return [2 /*return*/];
+                        oldVisualParams = visual.transform.params;
+                        this.visualTypeParamCache[oldVisualParams.type.name] = oldVisualParams.type.params;
+                        if (!(volumeType === 'off')) return [3 /*break*/, 1];
+                        (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, true); // true means hide, ¯\_(ツ)_/¯
+                        return [3 /*break*/, 3];
+                    case 1:
+                        (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, false); // true means hide, ¯\_(ツ)_/¯
+                        newVisualParams = tslib_1.__assign(tslib_1.__assign({}, oldVisualParams), { type: {
+                                name: volumeType,
+                                params: (_a = this.visualTypeParamCache[volumeType]) !== null && _a !== void 0 ? _a : oldVisualParams.type.params,
+                            } });
+                        newVisualParams.type.params.alpha = opacity;
+                        volumeStats = (_b = visual.obj) === null || _b === void 0 ? void 0 : _b.data.sourceData.grid.stats;
+                        if (!volumeStats)
+                            throw new Error("Cannot get volume stats from volume visual ".concat(visual.transform.ref));
+                        this.changeIsovalueInVolumeVisualParams(newVisualParams, undefined, volumeStats);
+                        update = this.entryData.newUpdate().to(visual.transform.ref).update(newVisualParams);
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.entryData.plugin, { state: this.entryData.plugin.state.data, tree: update, options: { doNotUpdateCurrent: true } })];
+                    case 2:
+                        _c.sent();
+                        _c.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegVolumeData.prototype.setTryUseGpu = function (tryUseGpu) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visuals, _i, visuals_1, visual, oldParams, newParams, update;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        visuals = this.entryData.findNodesByTags(exports.VOLUME_VISUAL_TAG);
+                        _i = 0, visuals_1 = visuals;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < visuals_1.length)) return [3 /*break*/, 4];
+                        visual = visuals_1[_i];
+                        oldParams = visual.transform.params;
+                        if (!(oldParams.type.params.tryUseGpu === !tryUseGpu)) return [3 /*break*/, 3];
+                        newParams = tslib_1.__assign(tslib_1.__assign({}, oldParams), { type: tslib_1.__assign(tslib_1.__assign({}, oldParams.type), { params: tslib_1.__assign(tslib_1.__assign({}, oldParams.type.params), { tryUseGpu: tryUseGpu }) }) });
+                        update = this.entryData.newUpdate().to(visual.transform.ref).update(newParams);
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.entryData.plugin, { state: this.entryData.plugin.state.data, tree: update, options: { doNotUpdateCurrent: true } })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegVolumeData.prototype.getIsovalueFromState = function () {
+        var _a = this.entryData.currentState.value, volumeIsovalueKind = _a.volumeIsovalueKind, volumeIsovalueValue = _a.volumeIsovalueValue;
+        return volumeIsovalueKind === 'relative'
+            ? volume_1.Volume.IsoValue.relative(volumeIsovalueValue)
+            : volume_1.Volume.IsoValue.absolute(volumeIsovalueValue);
+    };
+    VolsegVolumeData.prototype.createVolumeVisualParams = function (volume, type) {
+        var _a;
+        if (type === 'off')
+            type = 'isosurface';
+        return (0, volume_representation_params_1.createVolumeRepresentationParams)(this.entryData.plugin, volume, {
+            type: type,
+            typeParams: { alpha: 0.2, tryUseGpu: (_a = global_state_1.VolsegGlobalStateData.getGlobalState(this.entryData.plugin)) === null || _a === void 0 ? void 0 : _a.tryUseGpu },
+            color: 'uniform',
+            colorParams: { value: (0, color_1.Color)(0x121212) },
+        });
+    };
+    VolsegVolumeData.prototype.changeIsovalueInVolumeVisualParams = function (params, isovalue, stats) {
+        var _a;
+        isovalue !== null && isovalue !== void 0 ? isovalue : (isovalue = this.getIsovalueFromState());
+        switch (params.type.name) {
+            case 'isosurface':
+                params.type.params.isoValue = isovalue;
+                params.type.params.tryUseGpu = (_a = global_state_1.VolsegGlobalStateData.getGlobalState(this.entryData.plugin)) === null || _a === void 0 ? void 0 : _a.tryUseGpu;
+                break;
+            case 'direct-volume':
+                var absIso = volume_1.Volume.IsoValue.toAbsolute(isovalue, stats).absoluteValue;
+                var fractIso = (absIso - stats.min) / (stats.max - stats.min);
+                var peakHalfwidth = DIRECT_VOLUME_RELATIVE_PEAK_HALFWIDTH * stats.sigma / (stats.max - stats.min);
+                params.type.params.controlPoints = [
+                    linear_algebra_1.Vec2.create(Math.max(fractIso - peakHalfwidth, 0), 0),
+                    linear_algebra_1.Vec2.create(fractIso, 1),
+                    linear_algebra_1.Vec2.create(Math.min(fractIso + peakHalfwidth, 1), 0),
+                ];
+                break;
+        }
+    };
+    return VolsegVolumeData;
+}());
+exports.VolsegVolumeData = VolsegVolumeData;

package/lib/commonjs/extensions/volumes-and-segmentations/external-api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+/** Try to get author-defined contour value for isosurface from EMDB API. Return relative value 1.0, if not applicable or fails.  */
+export declare function tryGetIsovalue(entryId: string): Promise<{
+    kind: 'absolute' | 'relative';
+    value: number;
+} | undefined>;
+export declare function getPdbIdsForEmdbEntry(entryId: string): Promise<string[]>;