molstar 3.26.0 → 3.28.0

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

@@ -0,0 +1,576 @@
+"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.VolsegEntryData = exports.VolsegEntry = exports.VolsegEntryParamValues = exports.createVolsegEntryParams = exports.createLoadVolsegParams = exports.BOX = exports.MAX_VOXELS = void 0;
+var tslib_1 = require("tslib");
+var rxjs_1 = require("rxjs");
+var _1 = require(".");
+var shape_1 = require("../../mol-model/shape");
+var volume_1 = require("../../mol-model/volume");
+var objects_1 = require("../../mol-plugin-state/objects");
+var behavior_1 = require("../../mol-plugin/behavior");
+var commands_1 = require("../../mol-plugin/commands");
+var mol_state_1 = require("../../mol-state");
+var mol_util_1 = require("../../mol-util");
+var param_definition_1 = require("../../mol-util/param-definition");
+var api_1 = require("./volseg-api/api");
+var utils_1 = require("./volseg-api/utils");
+var entry_meshes_1 = require("./entry-meshes");
+var entry_models_1 = require("./entry-models");
+var entry_segmentation_1 = require("./entry-segmentation");
+var entry_state_1 = require("./entry-state");
+var entry_volume_1 = require("./entry-volume");
+var ExternalAPIs = tslib_1.__importStar(require("./external-api"));
+var global_state_1 = require("./global-state");
+var helpers_1 = require("./helpers");
+exports.MAX_VOXELS = Math.pow(10, 7);
+// export const MAX_VOXELS = 10 ** 2; // DEBUG
+exports.BOX = null;
+// export const BOX: [[number, number, number], [number, number, number]] | null = [[-90, -90, -90], [90, 90, 90]]; // DEBUG
+var MAX_ANNOTATIONS_IN_LABEL = 6;
+var SourceChoice = new helpers_1.Choice({ emdb: 'EMDB', empiar: 'EMPIAR', idr: 'IDR' }, 'emdb');
+function createLoadVolsegParams(plugin, entrylists) {
+    var _a;
+    if (entrylists === void 0) { entrylists = {}; }
+    var defaultVolumeServer = (_a = plugin === null || plugin === void 0 ? void 0 : plugin.config.get(_1.VolsegVolumeServerConfig.DefaultServer)) !== null && _a !== void 0 ? _a : api_1.DEFAULT_VOLSEG_SERVER;
+    return {
+        serverUrl: param_definition_1.ParamDefinition.Text(defaultVolumeServer),
+        source: param_definition_1.ParamDefinition.Mapped(SourceChoice.values[0], SourceChoice.options, function (src) { return entryParam(entrylists[src]); }),
+    };
+}
+exports.createLoadVolsegParams = createLoadVolsegParams;
+function entryParam(entries) {
+    if (entries === void 0) { entries = []; }
+    var options = entries.map(function (e) { return [e, e]; });
+    options.push(['__custom__', 'Custom']);
+    return param_definition_1.ParamDefinition.Group({
+        entryId: param_definition_1.ParamDefinition.Select(options[0][0], options, { description: 'Choose an entry from the list, or choose "Custom" and type any entry ID (useful when using other than default server).' }),
+        customEntryId: param_definition_1.ParamDefinition.Text('', { hideIf: function (p) { return p.entryId !== '__custom__'; }, description: 'Entry identifier, including the source prefix, e.g. "emd-1832"' }),
+    }, { isFlat: true });
+}
+function createVolsegEntryParams(plugin) {
+    var _a;
+    var defaultVolumeServer = (_a = plugin === null || plugin === void 0 ? void 0 : plugin.config.get(_1.VolsegVolumeServerConfig.DefaultServer)) !== null && _a !== void 0 ? _a : api_1.DEFAULT_VOLSEG_SERVER;
+    return {
+        serverUrl: param_definition_1.ParamDefinition.Text(defaultVolumeServer),
+        source: SourceChoice.PDSelect(),
+        entryId: param_definition_1.ParamDefinition.Text('emd-1832', { description: 'Entry identifier, including the source prefix, e.g. "emd-1832"' }),
+    };
+}
+exports.createVolsegEntryParams = createVolsegEntryParams;
+var VolsegEntryParamValues;
+(function (VolsegEntryParamValues) {
+    function fromLoadVolsegParamValues(params) {
+        var entryId = params.source.params.entryId;
+        if (entryId === '__custom__') {
+            entryId = params.source.params.customEntryId;
+        }
+        return {
+            serverUrl: params.serverUrl,
+            source: params.source.name,
+            entryId: entryId
+        };
+    }
+    VolsegEntryParamValues.fromLoadVolsegParamValues = fromLoadVolsegParamValues;
+})(VolsegEntryParamValues = exports.VolsegEntryParamValues || (exports.VolsegEntryParamValues = {}));
+var VolsegEntry = /** @class */ (function (_super) {
+    tslib_1.__extends(VolsegEntry, _super);
+    function VolsegEntry() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return VolsegEntry;
+}(objects_1.PluginStateObject.CreateBehavior({ name: 'Vol & Seg Entry' })));
+exports.VolsegEntry = VolsegEntry;
+var VolsegEntryData = /** @class */ (function (_super) {
+    tslib_1.__extends(VolsegEntryData, _super);
+    function VolsegEntryData(plugin, params) {
+        var _this = _super.call(this, plugin, params) || this;
+        _this.ref = '';
+        _this.volumeData = new entry_volume_1.VolsegVolumeData(_this);
+        _this.latticeSegmentationData = new entry_segmentation_1.VolsegLatticeSegmentationData(_this);
+        _this.meshSegmentationData = new entry_meshes_1.VolsegMeshSegmentationData(_this);
+        _this.modelData = new entry_models_1.VolsegModelData(_this);
+        _this.highlightRequest = new rxjs_1.Subject();
+        _this.getStateNode = (0, helpers_1.lazyGetter)(function () { return _this.plugin.state.data.selectQ(function (q) { return q.byRef(_this.ref).subtree().ofType(entry_state_1.VolsegState); })[0]; }, 'Missing VolsegState node. Must first create VolsegState for this VolsegEntry.');
+        _this.currentState = new rxjs_1.BehaviorSubject(param_definition_1.ParamDefinition.getDefaultValues(entry_state_1.VolsegStateParams));
+        _this.currentVolume = new rxjs_1.BehaviorSubject(undefined);
+        _this.labelProvider = {
+            label: function (loci) {
+                var segmentId = _this.getSegmentIdFromLoci(loci);
+                if (segmentId === undefined)
+                    return;
+                var segment = _this.metadata.getSegment(segmentId);
+                if (!segment)
+                    return;
+                var annotLabels = segment.biological_annotation.external_references.map(function (annot) { return "".concat((0, helpers_1.applyEllipsis)(annot.label), " [").concat(annot.resource, ":").concat(annot.accession, "]"); });
+                if (annotLabels.length === 0)
+                    return;
+                if (annotLabels.length > MAX_ANNOTATIONS_IN_LABEL + 1) {
+                    var nHidden = annotLabels.length - MAX_ANNOTATIONS_IN_LABEL;
+                    annotLabels.length = MAX_ANNOTATIONS_IN_LABEL;
+                    annotLabels.push("(".concat(nHidden, " more annotations, click on the segment to see all)"));
+                }
+                return '<hr class="msp-highlight-info-hr"/>' + annotLabels.filter(helpers_1.isDefined).join('<br/>');
+            }
+        };
+        _this.plugin = plugin;
+        _this.api = new api_1.VolumeApiV2(params.serverUrl);
+        _this.source = params.source;
+        _this.entryId = params.entryId;
+        _this.entryNumber = (0, helpers_1.splitEntryId)(_this.entryId).entryNumber;
+        return _this;
+    }
+    VolsegEntryData.prototype.initialize = function () {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var metadata, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.api.getMetadata(this.source, this.entryId)];
+                    case 1:
+                        metadata = _c.sent();
+                        this.metadata = new utils_1.MetadataWrapper(metadata);
+                        _b = this;
+                        return [4 /*yield*/, ExternalAPIs.getPdbIdsForEmdbEntry((_a = this.metadata.raw.grid.general.source_db_id) !== null && _a !== void 0 ? _a : this.entryId)];
+                    case 2:
+                        _b.pdbs = _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.create = function (plugin, params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = new VolsegEntryData(plugin, params);
+                        return [4 /*yield*/, result.initialize()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.register = function (ref) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var params, volumeVisual, volumeRef;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                this.ref = ref;
+                this.plugin.managers.lociLabels.addProvider(this.labelProvider);
+                try {
+                    params = (_a = this.getStateNode().obj) === null || _a === void 0 ? void 0 : _a.data;
+                    if (params) {
+                        this.currentState.next(params);
+                    }
+                }
+                catch (_c) {
+                    // do nothing
+                }
+                volumeVisual = this.findNodesByTags(entry_volume_1.VOLUME_VISUAL_TAG)[0];
+                if (volumeVisual)
+                    this.currentVolume.next(volumeVisual.transform);
+                this.subscribeObservable(this.plugin.state.data.events.cell.stateUpdated, function (e) {
+                    var _a, _b;
+                    try {
+                        (_this.getStateNode());
+                    }
+                    catch (_c) {
+                        return;
+                    } // if state not does not exist yet
+                    if (e.cell.transform.ref === _this.getStateNode().transform.ref) {
+                        var newState = (_a = _this.getStateNode().obj) === null || _a === void 0 ? void 0 : _a.data;
+                        if (newState && !(0, mol_util_1.shallowEqualObjects)(newState, _this.currentState.value)) { // avoid repeated update
+                            _this.currentState.next(newState);
+                        }
+                    }
+                    else if ((_b = e.cell.transform.tags) === null || _b === void 0 ? void 0 : _b.includes(entry_volume_1.VOLUME_VISUAL_TAG)) {
+                        if (e.ref === volumeRef) {
+                            _this.currentVolume.next(e.cell.transform);
+                        }
+                        else if (mol_state_1.StateSelection.findAncestor(_this.plugin.state.data.tree, _this.plugin.state.data.cells, e.ref, function (a) { return a.transform.ref === ref; })) {
+                            volumeRef = e.ref;
+                            _this.currentVolume.next(e.cell.transform);
+                        }
+                    }
+                });
+                this.subscribeObservable(this.plugin.state.data.events.cell.removed, function (e) {
+                    if (e.ref === volumeRef) {
+                        volumeRef = undefined;
+                        _this.currentVolume.next(undefined);
+                    }
+                });
+                this.subscribeObservable(this.plugin.behaviors.interaction.click, function (e) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var loci, clickedSegment;
+                    return tslib_1.__generator(this, function (_a) {
+                        loci = e.current.loci;
+                        clickedSegment = this.getSegmentIdFromLoci(loci);
+                        if (clickedSegment === undefined)
+                            return [2 /*return*/];
+                        if (clickedSegment === this.currentState.value.selectedSegment) {
+                            this.actionSelectSegment(undefined);
+                        }
+                        else {
+                            this.actionSelectSegment(clickedSegment);
+                        }
+                        return [2 /*return*/];
+                    });
+                }); });
+                this.subscribeObservable(this.highlightRequest.pipe((0, rxjs_1.throttleTime)(50, undefined, { leading: true, trailing: true })), function (segment) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.highlightSegment(segment)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                }); }); });
+                this.subscribeObservable(this.currentState.pipe((0, rxjs_1.distinctUntilChanged)(function (a, b) { return a.selectedSegment === b.selectedSegment; })), function (state) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var _a;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                if (!((_a = global_state_1.VolsegGlobalStateData.getGlobalState(this.plugin)) === null || _a === void 0 ? void 0 : _a.selectionMode)) return [3 /*break*/, 2];
+                                return [4 /*yield*/, this.selectSegment(state.selectedSegment)];
+                            case 1:
+                                _b.sent();
+                                _b.label = 2;
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                return [2 /*return*/];
+            });
+        });
+    };
+    VolsegEntryData.prototype.unregister = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.plugin.managers.lociLabels.removeProvider(this.labelProvider);
+                return [2 /*return*/];
+            });
+        });
+    };
+    VolsegEntryData.prototype.loadVolume = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, isovalue;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.volumeData.loadVolume()];
+                    case 1:
+                        result = _a.sent();
+                        if (!result) return [3 /*break*/, 3];
+                        isovalue = result.isovalue.kind === 'relative' ? result.isovalue.relativeValue : result.isovalue.absoluteValue;
+                        return [4 /*yield*/, this.updateStateNode({ volumeIsovalueKind: result.isovalue.kind, volumeIsovalueValue: isovalue })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.loadSegmentations = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.latticeSegmentationData.loadSegmentation()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.meshSegmentationData.loadSegmentation()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.actionShowSegments(this.metadata.allSegmentIds)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionHighlightSegment = function (segment) {
+        this.highlightRequest.next(segment);
+    };
+    VolsegEntryData.prototype.actionToggleSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var current;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        current = this.currentState.value.visibleSegments.map(function (seg) { return seg.segmentId; });
+                        if (!current.includes(segment)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.actionShowSegments(current.filter(function (s) { return s !== segment; }))];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.actionShowSegments(tslib_1.__spreadArray(tslib_1.__spreadArray([], current, true), [segment], false))];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionToggleAllSegments = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var current;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        current = this.currentState.value.visibleSegments.map(function (seg) { return seg.segmentId; });
+                        if (!(current.length !== this.metadata.allSegments.length)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.actionShowSegments(this.metadata.allSegmentIds)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.actionShowSegments([])];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionSelectSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(segment !== undefined && this.currentState.value.visibleSegments.find(function (s) { return s.segmentId === segment; }) === undefined)) return [3 /*break*/, 2];
+                        // first make the segment visible if it is not
+                        return [4 /*yield*/, this.actionToggleSegment(segment)];
+                    case 1:
+                        // first make the segment visible if it is not
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.updateStateNode({ selectedSegment: segment })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionSetOpacity = function (opacity) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (opacity === ((_a = this.getStateNode().obj) === null || _a === void 0 ? void 0 : _a.data.segmentOpacity))
+                            return [2 /*return*/];
+                        this.latticeSegmentationData.updateOpacity(opacity);
+                        this.meshSegmentationData.updateOpacity(opacity);
+                        return [4 /*yield*/, this.updateStateNode({ segmentOpacity: opacity })];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionShowFittedModel = function (pdbIds) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.modelData.showPdbs(pdbIds)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.updateStateNode({ visibleModels: pdbIds.map(function (pdbId) { return ({ pdbId: pdbId }); }) })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionSetVolumeVisual = function (type) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.volumeData.setVolumeVisual(type)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.updateStateNode({ volumeType: type })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionUpdateVolumeVisual = function (params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.volumeData.updateVolumeVisual(params)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.updateStateNode({
+                                volumeType: params.volumeType,
+                                volumeOpacity: params.opacity,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.actionShowSegments = function (segments) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.latticeSegmentationData.showSegments(segments)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.meshSegmentationData.showSegments(segments)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.updateStateNode({ visibleSegments: segments.map(function (s) { return ({ segmentId: s }); }) })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.highlightSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, commands_1.PluginCommands.Interactivity.ClearHighlights(this.plugin)];
+                    case 1:
+                        _a.sent();
+                        if (!segment) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.latticeSegmentationData.highlightSegment(segment)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.meshSegmentationData.highlightSegment(segment)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.selectSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.plugin.managers.interactivity.lociSelects.deselectAll();
+                        return [4 /*yield*/, this.latticeSegmentationData.selectSegment(segment)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.meshSegmentationData.selectSegment(segment)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.highlightSegment()];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.updateStateNode = function (params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var oldParams, newParams, state, update;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        oldParams = this.getStateNode().transform.params;
+                        newParams = tslib_1.__assign(tslib_1.__assign({}, oldParams), params);
+                        state = this.plugin.state.data;
+                        update = state.build().to(this.getStateNode().transform.ref).update(newParams);
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: update, options: { doNotUpdateCurrent: true } })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Find the nodes under this entry root which have all of the given tags. */
+    VolsegEntryData.prototype.findNodesByTags = function () {
+        var _this = this;
+        var tags = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            tags[_i] = arguments[_i];
+        }
+        return this.plugin.state.data.selectQ(function (q) {
+            var builder = q.byRef(_this.ref).subtree();
+            for (var _i = 0, tags_1 = tags; _i < tags_1.length; _i++) {
+                var tag = tags_1[_i];
+                builder = builder.withTag(tag);
+            }
+            return builder;
+        });
+    };
+    VolsegEntryData.prototype.newUpdate = function () {
+        if (this.ref !== '') {
+            return this.plugin.build().to(this.ref);
+        }
+        else {
+            return this.plugin.build().toRoot();
+        }
+    };
+    VolsegEntryData.prototype.getSegmentIdFromLoci = function (loci) {
+        var _a;
+        if (volume_1.Volume.Segment.isLoci(loci) && loci.volume._propertyData.ownerId === this.ref) {
+            if (loci.segments.length === 1) {
+                return loci.segments[0];
+            }
+        }
+        if (shape_1.ShapeGroup.isLoci(loci)) {
+            var meshData = ((_a = loci.shape.sourceData) !== null && _a !== void 0 ? _a : {});
+            if (meshData.ownerId === this.ref && meshData.segmentId !== undefined) {
+                return meshData.segmentId;
+            }
+        }
+    };
+    VolsegEntryData.prototype.setTryUseGpu = function (tryUseGpu) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.volumeData.setTryUseGpu(tryUseGpu),
+                            this.latticeSegmentationData.setTryUseGpu(tryUseGpu),
+                        ])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegEntryData.prototype.setSelectionMode = function (selectSegments) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!selectSegments) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.selectSegment(this.currentState.value.selectedSegment)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this.plugin.managers.interactivity.lociSelects.deselectAll();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return VolsegEntryData;
+}(behavior_1.PluginBehavior.WithSubscribers));
+exports.VolsegEntryData = VolsegEntryData;

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

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Segment } from './volseg-api/data';
+import { VolsegEntryData } from './entry-root';
+export declare class VolsegLatticeSegmentationData {
+    private entryData;
+    constructor(rootData: VolsegEntryData);
+    loadSegmentation(): Promise<void>;
+    private createPalette;
+    updateOpacity(opacity: number): Promise<import("../../mol-state").StateObjectSelector<import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, import("../../mol-state/transformer").StateTransformer<import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, any>>>;
+    private makeLoci;
+    highlightSegment(segment: Segment): Promise<void>;
+    selectSegment(segment?: number): Promise<void>;
+    /** Make visible the specified set of lattice segments */
+    showSegments(segments: number[]): Promise<void>;
+    setTryUseGpu(tryUseGpu: boolean): Promise<void>;
+}