molstar 3.26.0 → 3.28.0

package/lib/extensions/meshes/examples.js

@@ -0,0 +1,325 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __generator } from "tslib";
+/** Testing examples for using mesh-extension.ts. */
+import { ParseMeshlistTransformer, MeshShapeTransformer, MeshlistData } from './mesh-extension';
+import * as MeshUtils from './mesh-utils';
+import { BACKGROUND_OPACITY, FOREROUND_OPACITY, InitMeshStreaming } from './mesh-streaming/transformers';
+import { MeshServerInfo } from './mesh-streaming/server-info';
+import { Color } from '../../mol-util/color';
+import { Download } from '../../mol-plugin-state/transforms/data';
+import { StateTransforms } from '../../mol-plugin-state/transforms';
+import { Box3D } from '../../mol-math/geometry';
+import { ShapeRepresentation3D } from '../../mol-plugin-state/transforms/representation';
+import { ParamDefinition } from '../../mol-util/param-definition';
+import { createStructureRepresentationParams } from '../../mol-plugin-state/helpers/structure-representation-params';
+import { Volume } from '../../mol-model/volume';
+import { createVolumeRepresentationParams } from '../../mol-plugin-state/helpers/volume-representation-params';
+import { Asset } from '../../mol-util/assets';
+import { CIF } from '../../mol-io/reader/cif';
+export var DB_URL = '/db'; // local
+export function runMeshExtensionExamples(plugin, db_url) {
+    if (db_url === void 0) { db_url = DB_URL; }
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.time('TIME MESH EXAMPLES');
+                    // await runIsosurfaceExample(plugin, db_url);
+                    // await runMolsurfaceExample(plugin);
+                    // Focused Ion Beam-Scanning Electron Microscopy of mitochondrial reticulum in murine skeletal muscle: https://www.ebi.ac.uk/empiar/EMPIAR-10070/
+                    // await runMeshExample(plugin, 'all', db_url);
+                    // await runMeshExample(plugin, 'fg', db_url);
+                    // await runMultimeshExample(plugin, 'fg', 'worst', db_url);
+                    // await runCifMeshExample(plugin);
+                    // await runMeshExample2(plugin, 'fg');
+                    return [4 /*yield*/, runMeshStreamingExample(plugin)];
+                case 1:
+                    // await runIsosurfaceExample(plugin, db_url);
+                    // await runMolsurfaceExample(plugin);
+                    // Focused Ion Beam-Scanning Electron Microscopy of mitochondrial reticulum in murine skeletal muscle: https://www.ebi.ac.uk/empiar/EMPIAR-10070/
+                    // await runMeshExample(plugin, 'all', db_url);
+                    // await runMeshExample(plugin, 'fg', db_url);
+                    // await runMultimeshExample(plugin, 'fg', 'worst', db_url);
+                    // await runCifMeshExample(plugin);
+                    // await runMeshExample2(plugin, 'fg');
+                    _a.sent();
+                    console.timeEnd('TIME MESH EXAMPLES');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+export function runMeshExample(plugin, segments, db_url) {
+    if (db_url === void 0) { db_url = DB_URL; }
+    return __awaiter(this, void 0, void 0, function () {
+        var detail, segmentIds, _i, segmentIds_1, segmentId;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    detail = 2;
+                    segmentIds = (segments === 'all') ?
+                        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17] // segment-16 has no detail-2
+                        : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 17];
+                    _i = 0, segmentIds_1 = segmentIds;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < segmentIds_1.length)) return [3 /*break*/, 4];
+                    segmentId = segmentIds_1[_i];
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "".concat(db_url, "/empiar-10070-mesh-rounded/segment-").concat(segmentId, "/detail-").concat(detail), segmentId, detail, true, undefined)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+export function runMeshExample2(plugin, segments) {
+    return __awaiter(this, void 0, void 0, function () {
+        var detail, segmentIds, _i, segmentIds_2, segmentId;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    detail = 1;
+                    segmentIds = (segments === 'one') ? [15]
+                        : (segments === 'few') ? [1, 4, 7, 10, 16]
+                            : (segments === 'all') ? [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17] // segment-16 has no detail-2
+                                : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 17];
+                    _i = 0, segmentIds_2 = segmentIds;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < segmentIds_2.length)) return [3 /*break*/, 4];
+                    segmentId = segmentIds_2[_i];
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "http://localhost:9000/v2/empiar/empiar-10070/mesh_bcif/".concat(segmentId, "/").concat(detail), segmentId, detail, false, undefined)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Example for downloading a single segment containing multiple meshes. */
+export function runMultimeshExample(plugin, segments, detailChoice, db_url) {
+    if (db_url === void 0) { db_url = DB_URL; }
+    return __awaiter(this, void 0, void 0, function () {
+        var urlDetail, numDetail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    urlDetail = (detailChoice === 'best') ? '2' : 'worst';
+                    numDetail = (detailChoice === 'best') ? 2 : 1000;
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "".concat(db_url, "/empiar-10070-multimesh-rounded/segments-").concat(segments, "/detail-").concat(urlDetail), 0, numDetail, false, undefined)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Download data and create state tree hierarchy down to visual representation. */
+export function createMeshFromUrl(plugin, meshDataUrl, segmentId, detail, collapseTree, color, parent, transparentIfBboxAbove, name, ownerId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var update, rawDataNodeRef, parsedDataNode, transparent, bbox;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    update = parent ? plugin.build().to(parent) : plugin.build().toRoot();
+                    rawDataNodeRef = update.apply(Download, { url: meshDataUrl, isBinary: true, label: "Downloaded Data ".concat(segmentId) }, { state: { isCollapsed: collapseTree } }).ref;
+                    return [4 /*yield*/, update.to(rawDataNodeRef)
+                            .apply(StateTransforms.Data.ParseCif)
+                            .apply(ParseMeshlistTransformer, { label: undefined, segmentId: segmentId, segmentName: name !== null && name !== void 0 ? name : "Segment ".concat(segmentId), detail: detail, ownerId: ownerId }, {})
+                            .commit()];
+                case 1:
+                    parsedDataNode = _a.sent();
+                    transparent = false;
+                    if (transparentIfBboxAbove !== undefined && parsedDataNode.data) {
+                        bbox = MeshlistData.bbox(parsedDataNode.data) || Box3D.zero();
+                        transparent = Box3D.volume(bbox) > transparentIfBboxAbove;
+                    }
+                    return [4 /*yield*/, plugin.build().to(parsedDataNode)
+                            .apply(MeshShapeTransformer, { color: color })
+                            .apply(ShapeRepresentation3D, { alpha: transparent ? BACKGROUND_OPACITY : FOREROUND_OPACITY }, { tags: ['mesh-segment-visual', "segment-".concat(segmentId)] })
+                            .commit()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, rawDataNodeRef];
+            }
+        });
+    });
+}
+export function runMeshStreamingExample(plugin, source, entryId, serverUrl, parent) {
+    if (source === void 0) { source = 'empiar'; }
+    if (entryId === void 0) { entryId = 'empiar-10070'; }
+    return __awaiter(this, void 0, void 0, function () {
+        var params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = ParamDefinition.getDefaultValues(MeshServerInfo.Params);
+                    if (serverUrl)
+                        params.serverUrl = serverUrl;
+                    params.source = source;
+                    params.entryId = entryId;
+                    return [4 /*yield*/, plugin.runTask(plugin.state.data.applyAction(InitMeshStreaming, params, parent === null || parent === void 0 ? void 0 : parent.ref), { useOverlay: false })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Example for downloading a protein structure and visualizing molecular surface. */
+export function runMolsurfaceExample(plugin) {
+    return __awaiter(this, void 0, void 0, function () {
+        var entryId, data, parsed, trajectory, model, structure, reprParams, repr;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entryId = 'pdb-7etq';
+                    return [4 /*yield*/, plugin.builders.data.download({ url: 'https://www.ebi.ac.uk/pdbe/entry-files/download/7etq.bcif', isBinary: true }, { state: { isGhost: false } })];
+                case 1:
+                    data = _a.sent();
+                    console.log('formats:', plugin.dataFormats.list);
+                    return [4 /*yield*/, plugin.dataFormats.get('mmcif').parse(plugin, data, { entryId: entryId })];
+                case 2:
+                    parsed = _a.sent();
+                    trajectory = parsed.trajectory;
+                    console.log('parsed', parsed);
+                    console.log('trajectory', trajectory);
+                    return [4 /*yield*/, plugin.build().to(trajectory).apply(StateTransforms.Model.ModelFromTrajectory).commit()];
+                case 3:
+                    model = _a.sent();
+                    console.log('model:', model);
+                    return [4 /*yield*/, plugin.build().to(model).apply(StateTransforms.Model.StructureFromModel).commit()];
+                case 4:
+                    structure = _a.sent();
+                    console.log('structure:', structure);
+                    reprParams = createStructureRepresentationParams(plugin, undefined, { type: 'molecular-surface' });
+                    return [4 /*yield*/, plugin.build().to(structure).apply(StateTransforms.Representation.StructureRepresentation3D, reprParams).commit()];
+                case 5:
+                    repr = _a.sent();
+                    console.log('repr:', repr);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Example for downloading an EMDB density data and visualizing isosurface. */
+export function runIsosurfaceExample(plugin, db_url) {
+    var _a, _b;
+    if (db_url === void 0) { db_url = DB_URL; }
+    return __awaiter(this, void 0, void 0, function () {
+        var entryId, isoLevel, root, data, parsed, volume, volumeData, volumeParams;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    entryId = 'emd-1832';
+                    isoLevel = 2.73;
+                    return [4 /*yield*/, plugin.build()];
+                case 1:
+                    root = _c.sent();
+                    return [4 /*yield*/, plugin.builders.data.download({ url: "".concat(db_url, "/emd-1832-box"), isBinary: true }, { state: { isGhost: false } })];
+                case 2:
+                    data = _c.sent();
+                    return [4 /*yield*/, plugin.dataFormats.get('dscif').parse(plugin, data, { entryId: entryId })];
+                case 3:
+                    parsed = _c.sent();
+                    volume = (_b = (_a = parsed.volumes) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : parsed.volume;
+                    volumeData = volume.cell.obj.data;
+                    console.log('data:', data);
+                    console.log('parsed:', parsed);
+                    console.log('volume:', volume);
+                    console.log('volumeData:', volumeData);
+                    return [4 /*yield*/, plugin.build()];
+                case 4:
+                    root = _c.sent();
+                    console.log('root:', root);
+                    console.log('to:', root.to(volume));
+                    console.log('toRoot:', root.toRoot());
+                    volumeParams = createVolumeRepresentationParams(plugin, volumeData, {
+                        type: 'isosurface',
+                        typeParams: {
+                            alpha: 0.5,
+                            isoValue: Volume.adjustedIsoValue(volumeData, isoLevel, 'relative'),
+                            visuals: ['solid'],
+                            sizeFactor: 1,
+                        },
+                        color: 'uniform',
+                        colorParams: { value: Color(0x00aaaa) },
+                    });
+                    root.to(volume).apply(StateTransforms.Representation.VolumeRepresentation3D, volumeParams);
+                    volumeParams = createVolumeRepresentationParams(plugin, volumeData, {
+                        type: 'isosurface',
+                        typeParams: {
+                            alpha: 1.0,
+                            isoValue: Volume.adjustedIsoValue(volumeData, isoLevel, 'relative'),
+                            visuals: ['wireframe'],
+                            sizeFactor: 1,
+                        },
+                        color: 'uniform',
+                        colorParams: { value: Color(0x8800aa) },
+                    });
+                    root.to(volume).apply(StateTransforms.Representation.VolumeRepresentation3D, volumeParams);
+                    return [4 /*yield*/, root.commit()];
+                case 5:
+                    _c.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+export function runCifMeshExample(plugin, api, source, entryId, segmentId, detail) {
+    if (api === void 0) { api = 'http://localhost:9000/v2'; }
+    if (source === void 0) { source = 'empiar'; }
+    if (entryId === void 0) { entryId = 'empiar-10070'; }
+    if (segmentId === void 0) { segmentId = 1; }
+    if (detail === void 0) { detail = 10; }
+    return __awaiter(this, void 0, void 0, function () {
+        var url;
+        return __generator(this, function (_a) {
+            url = "".concat(api, "/").concat(source, "/").concat(entryId, "/mesh_bcif/").concat(segmentId, "/").concat(detail);
+            getMeshFromBcif(plugin, url);
+            return [2 /*return*/];
+        });
+    });
+}
+function getMeshFromBcif(plugin, url) {
+    return __awaiter(this, void 0, void 0, function () {
+        var urlAsset, asset, parsed, mesh;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    urlAsset = Asset.getUrlAsset(plugin.managers.asset, url);
+                    return [4 /*yield*/, plugin.runTask(plugin.managers.asset.resolve(urlAsset, 'binary'))];
+                case 1:
+                    asset = _a.sent();
+                    return [4 /*yield*/, plugin.runTask(CIF.parseBinary(asset.data))];
+                case 2:
+                    parsed = _a.sent();
+                    if (parsed.isError) {
+                        plugin.log.error('VolumeStreaming, parsing CIF: ' + parsed.toString());
+                        return [2 /*return*/];
+                    }
+                    console.log('blocks:', parsed.result.blocks);
+                    return [4 /*yield*/, MeshUtils.meshFromCif(parsed.result)];
+                case 3:
+                    mesh = _a.sent();
+                    console.log(mesh);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/lib/extensions/meshes/mesh-cif-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Column, Database } from '../../mol-data/db';
+import { CifFrame } from '../../mol-io/reader/cif';
+export declare const Mesh_Data_Schema: {
+    mesh: {
+        id: Column.Schema.Int;
+    };
+    mesh_vertex: {
+        mesh_id: Column.Schema.Int;
+        vertex_id: Column.Schema.Int;
+        x: Column.Schema.Float;
+        y: Column.Schema.Float;
+        z: Column.Schema.Float;
+    };
+    /** Table of triangles, 3 rows per triangle */
+    mesh_triangle: {
+        mesh_id: Column.Schema.Int;
+        /** Indices of vertices within mesh */
+        vertex_id: Column.Schema.Int;
+    };
+};
+export type Mesh_Data_Schema = typeof Mesh_Data_Schema;
+export interface Mesh_Data_Database extends Database<Mesh_Data_Schema> {
+}
+export declare const CIF_schema_mesh: (frame: CifFrame) => Mesh_Data_Database;

package/lib/extensions/meshes/mesh-cif-schema.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Column } from '../../mol-data/db';
+import { toDatabase } from '../../mol-io/reader/cif/schema';
+var int = Column.Schema.int;
+var float = Column.Schema.float;
+// TODO in future, move to molstar/src/mol-io/reader/cif/schema/mesh.ts
+export var Mesh_Data_Schema = {
+    mesh: {
+        id: int,
+    },
+    mesh_vertex: {
+        mesh_id: int,
+        vertex_id: int,
+        x: float,
+        y: float,
+        z: float,
+    },
+    /** Table of triangles, 3 rows per triangle */
+    mesh_triangle: {
+        mesh_id: int,
+        /** Indices of vertices within mesh */
+        vertex_id: int,
+    }
+};
+// TODO in future, move to molstar/src/mol-io/reader/cif.ts: CIF.schema.mesh
+export var CIF_schema_mesh = function (frame) { return toDatabase(Mesh_Data_Schema, frame); };

package/lib/extensions/meshes/mesh-extension.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
+import { CifFile } from '../../mol-io/reader/cif';
+import { Box3D } from '../../mol-math/geometry';
+import { Shape } from '../../mol-model/shape';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { StateTransformer } from '../../mol-state';
+import { Color } from '../../mol-util/color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+export declare const VolsegTransform: StateTransformer.Builder.Root;
+/** Data type for `MeshlistStateObject` - list of meshes */
+export interface MeshlistData {
+    segmentId: number;
+    segmentName: string;
+    detail: number;
+    meshIds: number[];
+    mesh: Mesh;
+    /** Reference to the object which created this meshlist (e.g. `MeshStreaming.Behavior`) */
+    ownerId?: string;
+}
+export declare namespace MeshlistData {
+    function empty(): MeshlistData;
+    function fromCIF(data: CifFile, segmentId: number, segmentName: string, detail: number): Promise<MeshlistData>;
+    function stats(meshListData: MeshlistData): string;
+    function getShape(data: MeshlistData, color: Color): Shape<Mesh>;
+    function combineBBoxes(boxes: (Box3D | null)[]): Box3D | null;
+    function bbox(data: MeshlistData): Box3D | null;
+    function allVerticesUsed(data: MeshlistData): boolean;
+}
+declare const MeshlistStateObject_base: {
+    new (data: MeshlistData, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: MeshlistData;
+    };
+    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: MeshlistData;
+    };
+};
+export declare class MeshlistStateObject extends MeshlistStateObject_base {
+}
+export declare const ParseMeshlistTransformer: StateTransformer<PluginStateObject.Format.Cif, MeshlistStateObject, PD.Normalize<{
+    label: string;
+    segmentId: number;
+    segmentName: string;
+    detail: number;
+    ownerId: string;
+}>>;
+export declare const MeshShapeTransformer: StateTransformer<MeshlistStateObject, PluginStateObject.Shape.Provider, PD.Normalize<{
+    color: Color | undefined;
+}>>;
+export {};

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

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __extends, __generator } from "tslib";
+/** Defines new types of State tree transformers for dealing with mesh data. */
+import { BaseGeometry, VisualQualityOptions } from '../../mol-geo/geometry/base';
+import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
+import { Box3D } from '../../mol-math/geometry';
+import { Vec3 } from '../../mol-math/linear-algebra';
+import { Shape } from '../../mol-model/shape';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { StateTransformer } from '../../mol-state';
+import { Task } from '../../mol-task';
+import { Material } from '../../mol-util/material';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import * as MeshUtils from './mesh-utils';
+export var VolsegTransform = StateTransformer.builderFactory('volseg');
+export var MeshlistData;
+(function (MeshlistData) {
+    function empty() {
+        return {
+            segmentId: 0,
+            segmentName: 'Empty',
+            detail: 0,
+            meshIds: [],
+            mesh: Mesh.createEmpty(),
+        };
+    }
+    MeshlistData.empty = empty;
+    ;
+    function fromCIF(data, segmentId, segmentName, detail) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, mesh, meshIds;
+            return __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.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) {
+                Vec3.min(result.min, result.min, box.min);
+                Vec3.max(result.max, result.max, box.max);
+            }
+            else {
+                result = Box3D.zero();
+                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 || (MeshlistData = {}));
+// // // // // // // // // // // // // // // // // // // // // // // //
+// Raw Data -> Parsed data
+var MeshlistStateObject = /** @class */ (function (_super) {
+    __extends(MeshlistStateObject, _super);
+    function MeshlistStateObject() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MeshlistStateObject;
+}(PluginStateObject.Create({ name: 'Parsed Meshlist', typeClass: 'Object' })));
+export { MeshlistStateObject };
+// QUESTION: is typeClass just for color, or does do something?
+export var ParseMeshlistTransformer = VolsegTransform({
+    name: 'meshlist-from-string',
+    from: PluginStateObject.Format.Cif,
+    to: MeshlistStateObject,
+    params: {
+        label: PD.Text(MeshlistStateObject.type.name, { isHidden: true }),
+        segmentId: PD.Numeric(1, {}, { isHidden: true }),
+        segmentName: PD.Text('Segment'),
+        detail: PD.Numeric(1, {}, { isHidden: true }),
+        /** Reference to the object which manages this meshlist (e.g. `MeshStreaming.Behavior`) */
+        ownerId: PD.Text('', { isHidden: true }),
+    }
+})({
+    apply: function (_a, globalCtx) {
+        var _this = this;
+        var a = _a.a, params = _a.params;
+        return Task.create('Create Parsed Meshlist', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+            var meshlistData, es;
+            return __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.Utils,
+            getShape: function (ctx, data) { return MeshlistData.getShape(data, theColor); },
+        };
+    }
+    MeshShapeProvider.fromMeshlistData = fromMeshlistData;
+})(MeshShapeProvider || (MeshShapeProvider = {}));
+/** Params for MeshShapeTransformer */
+var meshShapeParamDef = {
+    color: PD.Value(undefined), // undefined means random color
+};
+var meshParamDef = {
+    // These are basically original MS.Mesh.Params:
+    // BaseGeometry.Params
+    alpha: PD.Numeric(1, { min: 0, max: 1, step: 0.01 }, { label: 'Opacity', isEssential: true, description: 'How opaque/transparent the representation is rendered.' }),
+    quality: PD.Select('custom', VisualQualityOptions, { isEssential: true, description: 'Visual/rendering quality of the representation.' }),
+    material: Material.getParam(),
+    clip: Mesh.Params.clip,
+    instanceGranularity: PD.Boolean(false, { description: 'Use instance granularity for marker, transparency, clipping, overpaint, substance data to save memory.' }),
+    // Mesh.Params
+    doubleSided: PD.Boolean(true, BaseGeometry.CustomQualityParamInfo),
+    flipSided: PD.Boolean(false, BaseGeometry.ShadingCategory),
+    flatShaded: PD.Boolean(false, BaseGeometry.ShadingCategory),
+    ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory),
+    xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory),
+    transparentBackfaces: PD.Select('off', PD.arrayToOptions(['off', 'on', 'opaque']), BaseGeometry.ShadingCategory),
+    bumpFrequency: PD.Numeric(0, { min: 0, max: 10, step: 0.1 }, BaseGeometry.ShadingCategory),
+    bumpAmplitude: PD.Numeric(1, { min: 0, max: 5, step: 0.1 }, BaseGeometry.ShadingCategory),
+    // TODO when I change values here, it has effect, but not if I change them in GUI
+};
+export var MeshShapeTransformer = VolsegTransform({
+    name: 'shape-from-meshlist',
+    display: { name: 'Shape from Meshlist', description: 'Create Shape from Meshlist data' },
+    from: MeshlistStateObject,
+    to: 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 PluginStateObject.Shape.Provider(shapeProvider, { label: 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;
+// }