molstar 3.26.0 → 3.28.0

package/lib/commonjs/extensions/meshes/mesh-extension.js

@@ -0,0 +1,221 @@
+"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.MeshShapeTransformer = exports.ParseMeshlistTransformer = exports.MeshlistStateObject = exports.MeshlistData = exports.VolsegTransform = void 0;
+var tslib_1 = require("tslib");
+/** Defines new types of State tree transformers for dealing with mesh data. */
+var base_1 = require("../../mol-geo/geometry/base");
+var mesh_1 = require("../../mol-geo/geometry/mesh/mesh");
+var geometry_1 = require("../../mol-math/geometry");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var shape_1 = require("../../mol-model/shape");
+var objects_1 = require("../../mol-plugin-state/objects");
+var mol_state_1 = require("../../mol-state");
+var mol_task_1 = require("../../mol-task");
+var material_1 = require("../../mol-util/material");
+var param_definition_1 = require("../../mol-util/param-definition");
+var MeshUtils = tslib_1.__importStar(require("./mesh-utils"));
+exports.VolsegTransform = mol_state_1.StateTransformer.builderFactory('volseg');
+var MeshlistData;
+(function (MeshlistData) {
+    function empty() {
+        return {
+            segmentId: 0,
+            segmentName: 'Empty',
+            detail: 0,
+            meshIds: [],
+            mesh: mesh_1.Mesh.createEmpty(),
+        };
+    }
+    MeshlistData.empty = empty;
+    ;
+    function fromCIF(data, segmentId, segmentName, detail) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, mesh, meshIds;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, MeshUtils.meshFromCif(data)];
+                    case 1:
+                        _a = _b.sent(), mesh = _a.mesh, meshIds = _a.meshIds;
+                        return [2 /*return*/, {
+                                segmentId: segmentId,
+                                segmentName: segmentName,
+                                detail: detail,
+                                meshIds: meshIds,
+                                mesh: mesh,
+                            }];
+                }
+            });
+        });
+    }
+    MeshlistData.fromCIF = fromCIF;
+    function stats(meshListData) {
+        return "Meshlist \"".concat(meshListData.segmentName, "\" (detail ").concat(meshListData.detail, "): ").concat(meshListData.meshIds.length, " meshes, ").concat(meshListData.mesh.vertexCount, " vertices, ").concat(meshListData.mesh.triangleCount, " triangles");
+    }
+    MeshlistData.stats = stats;
+    function getShape(data, color) {
+        var mesh = data.mesh;
+        var meshShape = shape_1.Shape.create(data.segmentName, data, mesh, function () { return color; }, function () { return 1; }, 
+        // group => `${data.segmentName} | Segment ${data.segmentId} | Detail ${data.detail} | Mesh ${group}`,
+        function (group) { return data.segmentName; });
+        return meshShape;
+    }
+    MeshlistData.getShape = getShape;
+    function combineBBoxes(boxes) {
+        var result = null;
+        for (var _i = 0, boxes_1 = boxes; _i < boxes_1.length; _i++) {
+            var box = boxes_1[_i];
+            if (!box)
+                continue;
+            if (result) {
+                linear_algebra_1.Vec3.min(result.min, result.min, box.min);
+                linear_algebra_1.Vec3.max(result.max, result.max, box.max);
+            }
+            else {
+                result = geometry_1.Box3D.zero();
+                geometry_1.Box3D.copy(result, box);
+            }
+        }
+        return result;
+    }
+    MeshlistData.combineBBoxes = combineBBoxes;
+    function bbox(data) {
+        return MeshUtils.bbox(data.mesh);
+    }
+    MeshlistData.bbox = bbox;
+    function allVerticesUsed(data) {
+        var unusedVertices = new Set();
+        for (var i = 0; i < data.mesh.vertexCount; i++) {
+            unusedVertices.add(i);
+        }
+        for (var i = 0; i < 3 * data.mesh.triangleCount; i++) {
+            var v = data.mesh.vertexBuffer.ref.value[i];
+            unusedVertices.delete(v);
+        }
+        return unusedVertices.size === 0;
+    }
+    MeshlistData.allVerticesUsed = allVerticesUsed;
+})(MeshlistData = exports.MeshlistData || (exports.MeshlistData = {}));
+// // // // // // // // // // // // // // // // // // // // // // // //
+// Raw Data -> Parsed data
+var MeshlistStateObject = /** @class */ (function (_super) {
+    tslib_1.__extends(MeshlistStateObject, _super);
+    function MeshlistStateObject() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MeshlistStateObject;
+}(objects_1.PluginStateObject.Create({ name: 'Parsed Meshlist', typeClass: 'Object' })));
+exports.MeshlistStateObject = MeshlistStateObject;
+// QUESTION: is typeClass just for color, or does do something?
+exports.ParseMeshlistTransformer = (0, exports.VolsegTransform)({
+    name: 'meshlist-from-string',
+    from: objects_1.PluginStateObject.Format.Cif,
+    to: MeshlistStateObject,
+    params: {
+        label: param_definition_1.ParamDefinition.Text(MeshlistStateObject.type.name, { isHidden: true }),
+        segmentId: param_definition_1.ParamDefinition.Numeric(1, {}, { isHidden: true }),
+        segmentName: param_definition_1.ParamDefinition.Text('Segment'),
+        detail: param_definition_1.ParamDefinition.Numeric(1, {}, { isHidden: true }),
+        /** Reference to the object which manages this meshlist (e.g. `MeshStreaming.Behavior`) */
+        ownerId: param_definition_1.ParamDefinition.Text('', { isHidden: true }),
+    }
+})({
+    apply: function (_a, globalCtx) {
+        var _this = this;
+        var a = _a.a, params = _a.params;
+        return mol_task_1.Task.create('Create Parsed Meshlist', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var meshlistData, es;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, MeshlistData.fromCIF(a.data, params.segmentId, params.segmentName, params.detail)];
+                    case 1:
+                        meshlistData = _a.sent();
+                        meshlistData.ownerId = params.ownerId;
+                        es = meshlistData.meshIds.length === 1 ? '' : 'es';
+                        return [2 /*return*/, new MeshlistStateObject(meshlistData, { label: params.label, description: "".concat(meshlistData.segmentName, " (").concat(meshlistData.meshIds.length, " mesh").concat(es, ")") })];
+                }
+            });
+        }); });
+    }
+});
+var MeshShapeProvider;
+(function (MeshShapeProvider) {
+    function fromMeshlistData(meshlist, color) {
+        var theColor = color !== null && color !== void 0 ? color : MeshUtils.ColorGenerator.next().value;
+        return {
+            label: 'Mesh',
+            data: meshlist,
+            params: meshParamDef,
+            geometryUtils: mesh_1.Mesh.Utils,
+            getShape: function (ctx, data) { return MeshlistData.getShape(data, theColor); },
+        };
+    }
+    MeshShapeProvider.fromMeshlistData = fromMeshlistData;
+})(MeshShapeProvider || (MeshShapeProvider = {}));
+/** Params for MeshShapeTransformer */
+var meshShapeParamDef = {
+    color: param_definition_1.ParamDefinition.Value(undefined), // undefined means random color
+};
+var meshParamDef = {
+    // These are basically original MS.Mesh.Params:
+    // BaseGeometry.Params
+    alpha: param_definition_1.ParamDefinition.Numeric(1, { min: 0, max: 1, step: 0.01 }, { label: 'Opacity', isEssential: true, description: 'How opaque/transparent the representation is rendered.' }),
+    quality: param_definition_1.ParamDefinition.Select('custom', base_1.VisualQualityOptions, { isEssential: true, description: 'Visual/rendering quality of the representation.' }),
+    material: material_1.Material.getParam(),
+    clip: mesh_1.Mesh.Params.clip,
+    instanceGranularity: param_definition_1.ParamDefinition.Boolean(false, { description: 'Use instance granularity for marker, transparency, clipping, overpaint, substance data to save memory.' }),
+    // Mesh.Params
+    doubleSided: param_definition_1.ParamDefinition.Boolean(true, base_1.BaseGeometry.CustomQualityParamInfo),
+    flipSided: param_definition_1.ParamDefinition.Boolean(false, base_1.BaseGeometry.ShadingCategory),
+    flatShaded: param_definition_1.ParamDefinition.Boolean(false, base_1.BaseGeometry.ShadingCategory),
+    ignoreLight: param_definition_1.ParamDefinition.Boolean(false, base_1.BaseGeometry.ShadingCategory),
+    xrayShaded: param_definition_1.ParamDefinition.Boolean(false, base_1.BaseGeometry.ShadingCategory),
+    transparentBackfaces: param_definition_1.ParamDefinition.Select('off', param_definition_1.ParamDefinition.arrayToOptions(['off', 'on', 'opaque']), base_1.BaseGeometry.ShadingCategory),
+    bumpFrequency: param_definition_1.ParamDefinition.Numeric(0, { min: 0, max: 10, step: 0.1 }, base_1.BaseGeometry.ShadingCategory),
+    bumpAmplitude: param_definition_1.ParamDefinition.Numeric(1, { min: 0, max: 5, step: 0.1 }, base_1.BaseGeometry.ShadingCategory),
+    // TODO when I change values here, it has effect, but not if I change them in GUI
+};
+exports.MeshShapeTransformer = (0, exports.VolsegTransform)({
+    name: 'shape-from-meshlist',
+    display: { name: 'Shape from Meshlist', description: 'Create Shape from Meshlist data' },
+    from: MeshlistStateObject,
+    to: objects_1.PluginStateObject.Shape.Provider,
+    params: meshShapeParamDef
+})({
+    apply: function (_a) {
+        var a = _a.a, params = _a.params;
+        // you can look for example at ShapeFromPly in mol-plugin-state/tansforms/model.ts as an example
+        var shapeProvider = MeshShapeProvider.fromMeshlistData(a.data, params.color);
+        return new objects_1.PluginStateObject.Shape.Provider(shapeProvider, { label: objects_1.PluginStateObject.Shape.Provider.type.name, description: a.description });
+    }
+});
+// // // // // // // // // // // // // // // // // // // // // // // //
+// Shape -> Repr
+// type MeshRepr = MS.PluginStateObject.Representation3DData<MS.ShapeRepresentation<MS.ShapeProvider<any,any,any>, MS.Mesh, MS.Mesh.Params>, any>;
+// export const CustomMeshReprTransformer = VolsegTransform({
+//     name: 'custom-repr',
+//     from: MS.PluginStateObject.Shape.Provider, // later we can change this
+//     to: MS.PluginStateObject.Shape.Representation3D,
+// })({
+//     apply({ a }, globalCtx) {
+//         const repr: MeshRepr = createRepr(a.data); // TODO implement createRepr
+//         // have a look at MS.StateTransforms.Representation.ShapeRepresentation3D if you want to try implementing yourself
+//         return new MS.PluginStateObject.Shape.Representation3D(repr)
+//     },
+// })
+// export async function createMeshRepr(plugin: MS.PluginContext, data: any) {
+//     await plugin.build()
+//         .toRoot()
+//         .apply(CreateMyShapeTransformer, { data })
+//         .apply(MS.StateTransforms.Representation.ShapeRepresentation3D) // this should work
+//         // or .apply(CustomMeshRepr)
+//         .commit();
+// }
+// export function createRepr(reprData: MS.ShapeProvider<any,any,any>): MeshRepr {
+//     throw new Error('NotImplemented');
+//     return {} as MeshRepr;
+// }

package/lib/commonjs/extensions/meshes/mesh-streaming/behavior.d.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 { PluginBehavior } from '../../../mol-plugin/behavior';
+import { PluginContext } from '../../../mol-plugin/context';
+import { UUID } from '../../../mol-util';
+import { Color } from '../../../mol-util/color';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { Choice } from '../choice';
+import { MeshlistData } from '../mesh-extension';
+import { MeshServerInfo } from './server-info';
+export declare const NO_SEGMENT = -1;
+/** Segments whose bounding box volume is above this value (relative to the overall bounding box) are considered as background segments */
+export declare const BACKGROUND_SEGMENT_VOLUME_THRESHOLD = 0.5;
+declare const MeshStreaming_base: {
+    new (data: MeshStreaming.Behavior, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: MeshStreaming.Behavior;
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>> | undefined): obj is {
+        id: UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: MeshStreaming.Behavior;
+    };
+};
+export declare class MeshStreaming extends MeshStreaming_base {
+}
+export declare namespace MeshStreaming {
+    namespace Params {
+        const ViewTypeChoice: Choice<"all" | "select" | "off", "select">;
+        type ViewType = Choice.Values<typeof ViewTypeChoice>;
+        function create(options: MeshServerInfo.Data): {
+            view: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+                detail: number;
+            }>, "all"> | PD.NamedParams<PD.Normalize<{
+                baseDetail: number;
+                focusDetail: number;
+                selectedSegment: number;
+            }>, "select">>;
+        };
+        type Definition = ReturnType<typeof create>;
+        type Values = PD.Values<Definition>;
+        function copyValues(params: Values): Values;
+        function valuesEqual(p: Values, q: Values): boolean;
+        function detailsEqual(p: Values, q: Values): boolean;
+    }
+    interface VisualInfo {
+        tag: string;
+        segmentId: number;
+        segmentName: string;
+        detailType: VisualInfo.DetailType;
+        detail: number;
+        color: Color;
+        visible: boolean;
+        data?: MeshlistData;
+    }
+    namespace VisualInfo {
+        type DetailType = 'low' | 'high';
+        const DetailTypes: DetailType[];
+        function tagFor(segmentId: number, detail: DetailType): string;
+    }
+    class Behavior extends PluginBehavior.WithSubscribers<Params.Values> {
+        private id;
+        private ref;
+        parentData: MeshServerInfo.Data;
+        private metadata?;
+        visuals?: {
+            [tag: string]: VisualInfo;
+        };
+        backgroundSegments: {
+            [segmentId: number]: boolean;
+        };
+        private focusObservable;
+        private focusSubscription?;
+        private backgroundSegmentsInitialized;
+        constructor(plugin: PluginContext, data: MeshServerInfo.Data, params: Params.Values);
+        register(ref: string): void;
+        unregister(): void;
+        selectSegment(segmentId: number): void;
+        update(params: Params.Values): Promise<boolean>;
+        private getMetadataUrl;
+        private getMeshUrl;
+        private initVisualInfos;
+        private updateVisualInfoDetails;
+        private enableVisuals;
+        private disableVisuals;
+        /** Fetch data in current `visual.detail`, or return already fetched data (if available in the correct detail). */
+        private getMeshData;
+        private guessBackgroundSegments;
+        getDescription(): string;
+    }
+}
+export {};