molstar 3.26.0 → 3.28.0

package/lib/commonjs/mol-repr/volume/segment.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentRepresentationProvider = exports.SegmentRepresentation = exports.getSegmentParams = exports.SegmentParams = exports.SegmentTextureMeshVisual = exports.SegmentMeshVisual = exports.SegmentMeshParams = exports.createVolumeSegmentMesh = exports.eachSegment = exports.SegmentVisual = exports.VolumeSegmentParams = void 0;
+var tslib_1 = require("tslib");
+var param_definition_1 = require("../../mol-util/param-definition");
+var volume_1 = require("../../mol-model/volume");
+var mesh_1 = require("../../mol-geo/geometry/mesh/mesh");
+var algorithm_1 = require("../../mol-geo/util/marching-cubes/algorithm");
+var representation_1 = require("./representation");
+var location_iterator_1 = require("../../mol-geo/util/location-iterator");
+var representation_2 = require("../representation");
+var loci_1 = require("../../mol-model/loci");
+var int_1 = require("../../mol-data/int");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var array_1 = require("../../mol-util/array");
+var util_1 = require("./util");
+var texture_mesh_1 = require("../../mol-geo/geometry/texture-mesh/texture-mesh");
+var base_1 = require("../../mol-geo/geometry/base");
+var value_cell_1 = require("../../mol-util/value-cell");
+var isosurface_1 = require("../../mol-gl/compute/marching-cubes/isosurface");
+var box3d_1 = require("../../mol-math/geometry/primitives/box3d");
+exports.VolumeSegmentParams = {
+    segments: param_definition_1.ParamDefinition.Converted(function (v) { return v.map(function (x) { return "".concat(x); }); }, function (v) { return v.map(function (x) { return parseInt(x); }); }, param_definition_1.ParamDefinition.MultiSelect(['0'], param_definition_1.ParamDefinition.arrayToOptions(['0']), {
+        isEssential: true
+    }))
+};
+function gpuSupport(webgl) {
+    return webgl.extensions.colorBufferFloat && webgl.extensions.textureFloat && webgl.extensions.drawBuffers;
+}
+var Padding = 1;
+function suitableForGpu(volume, webgl) {
+    // small volumes are about as fast or faster on CPU vs integrated GPU
+    if (volume.grid.cells.data.length < Math.pow(10, 3))
+        return false;
+    // the GPU is much more memory contraint, especially true for integrated GPUs,
+    // fallback to CPU for large volumes
+    var gridDim = volume.grid.cells.space.dimensions;
+    var powerOfTwoSize = (0, util_1.getVolumeTexture2dLayout)(gridDim, Padding).powerOfTwoSize;
+    return powerOfTwoSize <= webgl.maxTextureSize / 2;
+}
+var _translate = (0, linear_algebra_1.Mat4)();
+function getSegmentTransform(grid, segmentBox) {
+    var transform = volume_1.Grid.getGridToCartesianTransform(grid);
+    var translate = linear_algebra_1.Mat4.fromTranslation(_translate, segmentBox.min);
+    return linear_algebra_1.Mat4.mul((0, linear_algebra_1.Mat4)(), transform, translate);
+}
+function SegmentVisual(materialId, volume, key, props, webgl) {
+    if (props.tryUseGpu && webgl && gpuSupport(webgl) && suitableForGpu(volume, webgl)) {
+        return SegmentTextureMeshVisual(materialId);
+    }
+    return SegmentMeshVisual(materialId);
+}
+exports.SegmentVisual = SegmentVisual;
+function getLoci(volume, props) {
+    return volume_1.Volume.Segment.Loci(volume, props.segments);
+}
+function getSegmentLoci(pickingId, volume, key, props, id) {
+    var objectId = pickingId.objectId, groupId = pickingId.groupId;
+    if (id === objectId) {
+        var granularity = volume_1.Volume.PickingGranularity.get(volume);
+        if (granularity === 'volume') {
+            return volume_1.Volume.Loci(volume);
+        }
+        else if (granularity === 'object') {
+            return volume_1.Volume.Segment.Loci(volume, [key]);
+        }
+        else {
+            return volume_1.Volume.Cell.Loci(volume, int_1.Interval.ofSingleton(groupId));
+        }
+    }
+    return loci_1.EmptyLoci;
+}
+function eachSegment(loci, volume, key, props, apply) {
+    var segments = int_1.SortedArray.ofSingleton(key);
+    return (0, util_1.eachVolumeLoci)(loci, volume, { segments: segments }, apply);
+}
+exports.eachSegment = eachSegment;
+//
+function getSegmentCells(set, bbox, cells) {
+    var data = cells.data;
+    var o = cells.space.dataOffset;
+    var dim = box3d_1.Box3D.size((0, linear_algebra_1.Vec3)(), bbox);
+    var xn = dim[0], yn = dim[1], zn = dim[2];
+    var xn1 = xn - 1;
+    var yn1 = yn - 1;
+    var zn1 = zn - 1;
+    var _a = bbox.min, minx = _a[0], miny = _a[1], minz = _a[2];
+    var _b = bbox.max, maxx = _b[0], maxy = _b[1], maxz = _b[2];
+    var axisOrder = tslib_1.__spreadArray([], cells.space.axisOrderSlowToFast, true);
+    var segmentSpace = linear_algebra_1.Tensor.Space(dim, axisOrder, Uint8Array);
+    var segmentCells = linear_algebra_1.Tensor.create(segmentSpace, segmentSpace.create());
+    var segData = segmentCells.data;
+    var segSet = segmentSpace.set;
+    for (var z = 0; z < zn; ++z) {
+        for (var y = 0; y < yn; ++y) {
+            for (var x = 0; x < xn; ++x) {
+                var v0 = set.includes(data[o(x + minx, y + miny, z + minz)]) ? 255 : 0;
+                var xp = set.includes(data[o(Math.min(xn1 + maxx, x + 1 + minx), y + miny, z + minz)]) ? 255 : 0;
+                var xn_1 = set.includes(data[o(Math.max(0, x - 1 + minx), y + miny, z + minz)]) ? 255 : 0;
+                var yp = set.includes(data[o(x + minx, Math.min(yn1 + maxy, y + 1 + miny), z + minz)]) ? 255 : 0;
+                var yn_1 = set.includes(data[o(x + minx, Math.max(0, y - 1 + miny), z + minz)]) ? 255 : 0;
+                var zp = set.includes(data[o(x + minx, y + miny, Math.min(zn1 + maxz, z + 1 + minz))]) ? 255 : 0;
+                var zn_1 = set.includes(data[o(x + minx, y + miny, Math.max(0, z - 1 + minz))]) ? 255 : 0;
+                segSet(segData, x, y, z, Math.round((v0 + v0 + xp + xn_1 + yp + yn_1 + zp + zn_1) / 8));
+            }
+        }
+    }
+    return segmentCells;
+}
+function createVolumeSegmentMesh(ctx, volume, key, theme, props, mesh) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var segmentation, bbox, set, cells, ids, surface, transform;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    segmentation = volume_1.Volume.Segmentation.get(volume);
+                    if (!segmentation)
+                        throw new Error('missing volume segmentation');
+                    ctx.runtime.update({ message: 'Marching cubes...' });
+                    bbox = box3d_1.Box3D.clone(segmentation.bounds[key]);
+                    box3d_1.Box3D.expand(bbox, bbox, linear_algebra_1.Vec3.create(2, 2, 2));
+                    set = Array.from(segmentation.segments.get(key).values());
+                    cells = getSegmentCells(set, bbox, volume.grid.cells);
+                    ids = (0, array_1.fillSerial)(new Int32Array(cells.data.length));
+                    return [4 /*yield*/, (0, algorithm_1.computeMarchingCubesMesh)({
+                            isoLevel: 128,
+                            scalarField: cells,
+                            idField: linear_algebra_1.Tensor.create(cells.space, linear_algebra_1.Tensor.Data1(ids))
+                        }, mesh).runAsChild(ctx.runtime)];
+                case 1:
+                    surface = _a.sent();
+                    transform = getSegmentTransform(volume.grid, bbox);
+                    mesh_1.Mesh.transform(surface, transform);
+                    if (ctx.webgl && !ctx.webgl.isWebGL2) {
+                        // 2nd arg means not to split triangles based on group id. Splitting triangles
+                        // is too expensive if each cell has its own group id as is the case here.
+                        mesh_1.Mesh.uniformTriangleGroup(surface, false);
+                        value_cell_1.ValueCell.updateIfChanged(surface.varyingGroup, false);
+                    }
+                    else {
+                        value_cell_1.ValueCell.updateIfChanged(surface.varyingGroup, true);
+                    }
+                    surface.setBoundingSphere(volume_1.Volume.Segment.getBoundingSphere(volume, [key]));
+                    return [2 /*return*/, surface];
+            }
+        });
+    });
+}
+exports.createVolumeSegmentMesh = createVolumeSegmentMesh;
+exports.SegmentMeshParams = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params), texture_mesh_1.TextureMesh.Params), exports.VolumeSegmentParams), { quality: tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params.quality), { isEssential: false }), tryUseGpu: param_definition_1.ParamDefinition.Boolean(true) });
+function SegmentMeshVisual(materialId) {
+    return (0, representation_1.VolumeVisual)({
+        defaultProps: param_definition_1.ParamDefinition.getDefaultValues(exports.SegmentMeshParams),
+        createGeometry: createVolumeSegmentMesh,
+        createLocationIterator: function (volume, key) {
+            var l = volume_1.Volume.Segment.Location(volume, key);
+            return (0, location_iterator_1.LocationIterator)(volume.grid.cells.data.length, 1, 1, function () { return l; });
+        },
+        getLoci: getSegmentLoci,
+        eachLocation: eachSegment,
+        setUpdateState: function (state, volume, newProps, currentProps) {
+        },
+        geometryUtils: mesh_1.Mesh.Utils,
+        mustRecreate: function (volumeKey, props, webgl) {
+            return props.tryUseGpu && !!webgl && suitableForGpu(volumeKey.volume, webgl);
+        }
+    }, materialId);
+}
+exports.SegmentMeshVisual = SegmentMeshVisual;
+//
+var SegmentTextureName = 'segment-texture';
+function getSegmentTexture(volume, segment, webgl) {
+    var segmentation = volume_1.Volume.Segmentation.get(volume);
+    if (!segmentation)
+        throw new Error('missing volume segmentation');
+    var resources = webgl.resources;
+    var bbox = box3d_1.Box3D.clone(segmentation.bounds[segment]);
+    box3d_1.Box3D.expand(bbox, bbox, linear_algebra_1.Vec3.create(2, 2, 2));
+    var transform = getSegmentTransform(volume.grid, bbox);
+    var gridDimension = box3d_1.Box3D.size((0, linear_algebra_1.Vec3)(), bbox);
+    var _a = (0, util_1.getVolumeTexture2dLayout)(gridDimension, Padding), width = _a.width, height = _a.height, texDim = _a.powerOfTwoSize;
+    var gridTexDim = linear_algebra_1.Vec3.create(width, height, 0);
+    var gridTexScale = linear_algebra_1.Vec2.create(width / texDim, height / texDim);
+    // console.log({ texDim, width, height, gridDimension });
+    if (texDim > webgl.maxTextureSize / 2) {
+        throw new Error('volume too large for gpu segment extraction');
+    }
+    if (!webgl.namedTextures[SegmentTextureName]) {
+        webgl.namedTextures[SegmentTextureName] = resources.texture('image-uint8', 'alpha', 'ubyte', 'linear');
+    }
+    var texture = webgl.namedTextures[SegmentTextureName];
+    texture.define(texDim, texDim);
+    // load volume into sub-section of texture
+    var set = Array.from(segmentation.segments.get(segment).values());
+    texture.load((0, util_1.createSegmentTexture2d)(volume, set, bbox, Padding), true);
+    gridDimension[0] += Padding;
+    gridDimension[1] += Padding;
+    return {
+        texture: texture,
+        transform: transform,
+        gridDimension: gridDimension,
+        gridTexDim: gridTexDim,
+        gridTexScale: gridTexScale
+    };
+}
+function createVolumeSegmentTextureMesh(ctx, volume, segment, theme, props, textureMesh) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var _a, texture, gridDimension, gridTexDim, gridTexScale, transform, axisOrder, buffer, gv, groupCount, surface;
+        return tslib_1.__generator(this, function (_b) {
+            if (!ctx.webgl)
+                throw new Error('webgl context required to create volume segment texture-mesh');
+            if (volume.grid.cells.data.length <= 1) {
+                return [2 /*return*/, texture_mesh_1.TextureMesh.createEmpty(textureMesh)];
+            }
+            _a = getSegmentTexture(volume, segment, ctx.webgl), texture = _a.texture, gridDimension = _a.gridDimension, gridTexDim = _a.gridTexDim, gridTexScale = _a.gridTexScale, transform = _a.transform;
+            axisOrder = volume.grid.cells.space.axisOrderSlowToFast;
+            buffer = textureMesh === null || textureMesh === void 0 ? void 0 : textureMesh.doubleBuffer.get();
+            gv = (0, isosurface_1.extractIsosurface)(ctx.webgl, texture, gridDimension, gridTexDim, gridTexScale, transform, 0.5, false, false, axisOrder, true, buffer === null || buffer === void 0 ? void 0 : buffer.vertex, buffer === null || buffer === void 0 ? void 0 : buffer.group, buffer === null || buffer === void 0 ? void 0 : buffer.normal);
+            groupCount = volume.grid.cells.data.length;
+            surface = texture_mesh_1.TextureMesh.create(gv.vertexCount, groupCount, gv.vertexTexture, gv.groupTexture, gv.normalTexture, volume_1.Volume.Segment.getBoundingSphere(volume, [segment]), textureMesh);
+            return [2 /*return*/, surface];
+        });
+    });
+}
+function SegmentTextureMeshVisual(materialId) {
+    return (0, representation_1.VolumeVisual)({
+        defaultProps: param_definition_1.ParamDefinition.getDefaultValues(exports.SegmentMeshParams),
+        createGeometry: createVolumeSegmentTextureMesh,
+        createLocationIterator: function (volume, segment) {
+            var l = volume_1.Volume.Segment.Location(volume, segment);
+            return (0, location_iterator_1.LocationIterator)(volume.grid.cells.data.length, 1, 1, function () { return l; });
+        },
+        getLoci: getSegmentLoci,
+        eachLocation: eachSegment,
+        setUpdateState: function (state, volume, newProps, currentProps) {
+        },
+        geometryUtils: texture_mesh_1.TextureMesh.Utils,
+        mustRecreate: function (volumeKey, props, webgl) {
+            return !props.tryUseGpu || !webgl || !suitableForGpu(volumeKey.volume, webgl);
+        },
+        dispose: function (geometry) {
+            geometry.vertexTexture.ref.value.destroy();
+            geometry.groupTexture.ref.value.destroy();
+            geometry.normalTexture.ref.value.destroy();
+            geometry.doubleBuffer.destroy();
+        }
+    }, materialId);
+}
+exports.SegmentTextureMeshVisual = SegmentTextureMeshVisual;
+//
+function getSegments(props) {
+    return int_1.SortedArray.ofUnsortedArray(props.segments);
+}
+var SegmentVisuals = {
+    'segment': function (ctx, getParams) { return (0, representation_1.VolumeRepresentation)('Segment mesh', ctx, getParams, SegmentVisual, getLoci, getSegments); },
+};
+exports.SegmentParams = tslib_1.__assign(tslib_1.__assign({}, exports.SegmentMeshParams), { visuals: param_definition_1.ParamDefinition.MultiSelect(['segment'], param_definition_1.ParamDefinition.objectToOptions(SegmentVisuals)), bumpFrequency: param_definition_1.ParamDefinition.Numeric(1, { min: 0, max: 10, step: 0.1 }, base_1.BaseGeometry.ShadingCategory) });
+function getSegmentParams(ctx, volume) {
+    var p = param_definition_1.ParamDefinition.clone(exports.SegmentParams);
+    var segmentation = volume_1.Volume.Segmentation.get(volume);
+    if (segmentation) {
+        var segments = Array.from(segmentation.segments.keys());
+        p.segments = param_definition_1.ParamDefinition.Converted(function (v) { return v.map(function (x) { return "".concat(x); }); }, function (v) { return v.map(function (x) { return parseInt(x); }); }, param_definition_1.ParamDefinition.MultiSelect(segments.map(function (x) { return "".concat(x); }), param_definition_1.ParamDefinition.arrayToOptions(segments.map(function (x) { return "".concat(x); })), {
+            isEssential: true
+        }));
+    }
+    return p;
+}
+exports.getSegmentParams = getSegmentParams;
+function SegmentRepresentation(ctx, getParams) {
+    return representation_2.Representation.createMulti('Segment', ctx, getParams, representation_2.Representation.StateBuilder, SegmentVisuals);
+}
+exports.SegmentRepresentation = SegmentRepresentation;
+exports.SegmentRepresentationProvider = (0, representation_1.VolumeRepresentationProvider)({
+    name: 'segment',
+    label: 'Segment',
+    description: 'Displays a triangulated segment of volumetric data.',
+    factory: SegmentRepresentation,
+    getParams: getSegmentParams,
+    defaultValues: param_definition_1.ParamDefinition.getDefaultValues(exports.SegmentParams),
+    defaultColorTheme: { name: 'volume-segment' },
+    defaultSizeTheme: { name: 'uniform' },
+    isApplicable: function (volume) { return !volume_1.Volume.isEmpty(volume) && !!volume_1.Volume.Segmentation.get(volume); }
+});

package/lib/commonjs/mol-repr/volume/slice.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ import { Volume } from '../../mol-model/volume';
 import { VolumeVisual, VolumeRepresentation, VolumeRepresentationProvider } from './representation';
 import { RepresentationContext, RepresentationParamsGetter } from '../representation';
 import { VisualContext } from '../visual';
-export declare function createImage(ctx: VisualContext, volume: Volume, theme: Theme, props: PD.Values<SliceParams>, image?: Image): Promise<Image>;
+export declare function createImage(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: PD.Values<SliceParams>, image?: Image): Promise<Image>;
 export declare const SliceParams: {
     quality: {
         isEssential: boolean;

package/lib/commonjs/mol-repr/volume/slice.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -20,7 +20,7 @@ var color_1 = require("../../mol-util/color");
 var color_2 = require("../../mol-theme/color");
 var number_packing_1 = require("../../mol-util/number-packing");
 var util_2 = require("./util");
-function createImage(ctx, volume, theme, props, image) {
+function createImage(ctx, volume, key, theme, props, image) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var dim, isoValue, _a, space, data, _b, min, max, isoVal, color, _c, r, g, b, _d, width, height, x, y, z, x0, y0, z0, nx, ny, nz, corners, imageArray, groupArray, i, iy, ix, iz, val, normVal, imageTexture, groupTexture, transform;
         return tslib_1.__generator(this, function (_e) {
@@ -130,7 +130,7 @@ function getLoci(volume, props) {
     var groupArray = getGroupArray(volume.grid, props);
     return volume_1.Volume.Cell.Loci(volume, int_1.SortedArray.ofUnsortedArray(groupArray));
 }
-function getSliceLoci(pickingId, volume, props, id) {
+function getSliceLoci(pickingId, volume, key, props, id) {
     var objectId = pickingId.objectId, groupId = pickingId.groupId;
     if (id === objectId) {
         var granularity = volume_1.Volume.PickingGranularity.get(volume);
@@ -146,7 +146,7 @@ function getSliceLoci(pickingId, volume, props, id) {
     }
     return loci_1.EmptyLoci;
 }
-function eachSlice(loci, volume, props, apply) {
+function eachSlice(loci, volume, key, props, apply) {
     return (0, util_2.eachVolumeLoci)(loci, volume, undefined, apply);
 }
 //
@@ -206,5 +206,5 @@ exports.SliceRepresentationProvider = (0, representation_1.VolumeRepresentationP
     defaultValues: param_definition_1.ParamDefinition.getDefaultValues(exports.SliceParams),
     defaultColorTheme: { name: 'uniform' },
     defaultSizeTheme: { name: 'uniform' },
-    isApplicable: function (volume) { return !volume_1.Volume.isEmpty(volume); }
+    isApplicable: function (volume) { return !volume_1.Volume.isEmpty(volume) && !volume_1.Volume.Segmentation.get(volume); }
 });

package/lib/commonjs/mol-repr/volume/util.d.ts

@@ -1,13 +1,17 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { Volume } from '../../mol-model/volume';
 import { Loci } from '../../mol-model/loci';
-import { Interval } from '../../mol-data/int';
+import { Interval, SortedArray } from '../../mol-data/int';
 import { Vec3 } from '../../mol-math/linear-algebra/3d/vec3';
-export declare function eachVolumeLoci(loci: Loci, volume: Volume, isoValue: Volume.IsoValue | undefined, apply: (interval: Interval) => boolean): boolean;
+import { Box3D } from '../../mol-math/geometry';
+export declare function eachVolumeLoci(loci: Loci, volume: Volume, props: {
+    isoValue?: Volume.IsoValue;
+    segments?: SortedArray;
+} | undefined, apply: (interval: Interval) => boolean): boolean;
 export declare function getVolumeTexture2dLayout(dim: Vec3, padding?: number): {
     width: number;
     height: number;
@@ -26,3 +30,8 @@ export declare function createVolumeTexture3d(volume: Volume): {
     height: number;
     depth: number;
 };
+export declare function createSegmentTexture2d(volume: Volume, set: number[], bbox: Box3D, padding?: number): {
+    array: Uint8Array;
+    width: number;
+    height: number;
+};

package/lib/commonjs/mol-repr/volume/util.js

@@ -1,16 +1,18 @@
 "use strict";
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVolumeTexture3d = exports.createVolumeTexture2d = exports.getVolumeTexture2dLayout = exports.eachVolumeLoci = void 0;
+exports.createSegmentTexture2d = exports.createVolumeTexture3d = exports.createVolumeTexture2d = exports.getVolumeTexture2dLayout = exports.eachVolumeLoci = void 0;
 var volume_1 = require("../../mol-model/volume");
 var int_1 = require("../../mol-data/int");
 var common_1 = require("../../mol-math/linear-algebra/3d/common");
 var vec3_1 = require("../../mol-math/linear-algebra/3d/vec3");
 var number_packing_1 = require("../../mol-util/number-packing");
+var set_1 = require("../../mol-util/set");
+var geometry_1 = require("../../mol-math/geometry");
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
 var v3set = vec3_1.Vec3.set;
 var v3normalize = vec3_1.Vec3.normalize;
@@ -18,7 +20,7 @@ var v3sub = vec3_1.Vec3.sub;
 var v3addScalar = vec3_1.Vec3.addScalar;
 var v3scale = vec3_1.Vec3.scale;
 var v3toArray = vec3_1.Vec3.toArray;
-function eachVolumeLoci(loci, volume, isoValue, apply) {
+function eachVolumeLoci(loci, volume, props, apply) {
     var changed = false;
     if (volume_1.Volume.isLoci(loci)) {
         if (!volume_1.Volume.areEquivalent(loci.volume, volume))
@@ -29,14 +31,13 @@ function eachVolumeLoci(loci, volume, isoValue, apply) {
     else if (volume_1.Volume.Isosurface.isLoci(loci)) {
         if (!volume_1.Volume.areEquivalent(loci.volume, volume))
             return false;
-        if (isoValue) {
-            if (!volume_1.Volume.IsoValue.areSame(loci.isoValue, isoValue, volume.grid.stats))
+        if (props === null || props === void 0 ? void 0 : props.isoValue) {
+            if (!volume_1.Volume.IsoValue.areSame(loci.isoValue, props.isoValue, volume.grid.stats))
                 return false;
             if (apply(int_1.Interval.ofLength(volume.grid.cells.data.length)))
                 changed = true;
         }
         else {
-            // TODO find a cheaper way?
             var _a = volume.grid, stats = _a.stats, data = _a.cells.data;
             var eps = stats.sigma;
             var v = volume_1.Volume.IsoValue.toAbsolute(loci.isoValue, stats).absoluteValue;
@@ -62,6 +63,33 @@ function eachVolumeLoci(loci, volume, isoValue, apply) {
             });
         }
     }
+    else if (volume_1.Volume.Segment.isLoci(loci)) {
+        if (!volume_1.Volume.areEquivalent(loci.volume, volume))
+            return false;
+        if (props === null || props === void 0 ? void 0 : props.segments) {
+            if (!int_1.SortedArray.areIntersecting(loci.segments, props.segments))
+                return false;
+            if (apply(int_1.Interval.ofLength(volume.grid.cells.data.length)))
+                changed = true;
+        }
+        else {
+            var segmentation = volume_1.Volume.Segmentation.get(volume);
+            if (segmentation) {
+                var set = new Set();
+                for (var i = 0, il = loci.segments.length; i < il; ++i) {
+                    set_1.SetUtils.add(set, segmentation.segments.get(loci.segments[i]));
+                }
+                var s = Array.from(set.values());
+                var d = volume.grid.cells.data;
+                for (var i = 0, il = d.length; i < il; ++i) {
+                    if (s.includes(d[i])) {
+                        if (apply(int_1.Interval.ofSingleton(i)))
+                            changed = true;
+                    }
+                }
+            }
+        }
+    }
     return changed;
 }
 exports.eachVolumeLoci = eachVolumeLoci;
@@ -165,3 +193,41 @@ function createVolumeTexture3d(volume) {
     return textureVolume;
 }
 exports.createVolumeTexture3d = createVolumeTexture3d;
+function createSegmentTexture2d(volume, set, bbox, padding) {
+    if (padding === void 0) { padding = 0; }
+    var data = volume.grid.cells.data;
+    var dim = geometry_1.Box3D.size((0, vec3_1.Vec3)(), bbox);
+    var o = volume.grid.cells.space.dataOffset;
+    var _a = getVolumeTexture2dLayout(dim, padding), width = _a.width, height = _a.height;
+    var itemSize = 1;
+    var array = new Uint8Array(width * height * itemSize);
+    var textureImage = { array: array, width: width, height: height };
+    var xn = dim[0], yn = dim[1], zn = dim[2];
+    var xn1 = xn - 1;
+    var yn1 = yn - 1;
+    var zn1 = zn - 1;
+    var xnp = xn + padding;
+    var ynp = yn + padding;
+    var _b = bbox.min, minx = _b[0], miny = _b[1], minz = _b[2];
+    var _c = bbox.max, maxx = _c[0], maxy = _c[1], maxz = _c[2];
+    for (var z = 0; z < zn; ++z) {
+        for (var y = 0; y < yn; ++y) {
+            for (var x = 0; x < xn; ++x) {
+                var column = Math.floor(((z * xnp) % width) / xnp);
+                var row = Math.floor((z * xnp) / width);
+                var px = column * xnp + x;
+                var index = itemSize * ((row * ynp * width) + (y * width) + px);
+                var v0 = set.includes(data[o(x + minx, y + miny, z + minz)]) ? 255 : 0;
+                var xp = set.includes(data[o(Math.min(xn1 + maxx, x + 1 + minx), y + miny, z + minz)]) ? 255 : 0;
+                var xn_1 = set.includes(data[o(Math.max(0, x - 1 + minx), y + miny, z + minz)]) ? 255 : 0;
+                var yp = set.includes(data[o(x + minx, Math.min(yn1 + maxy, y + 1 + miny), z + minz)]) ? 255 : 0;
+                var yn_1 = set.includes(data[o(x + minx, Math.max(0, y - 1 + miny), z + minz)]) ? 255 : 0;
+                var zp = set.includes(data[o(x + minx, y + miny, Math.min(zn1 + maxz, z + 1 + minz))]) ? 255 : 0;
+                var zn_1 = set.includes(data[o(x + minx, y + miny, Math.max(0, z - 1 + minz))]) ? 255 : 0;
+                array[index] = Math.round((v0 + v0 + xp + xn_1 + yp + yn_1 + zp + zn_1) / 8);
+            }
+        }
+    }
+    return textureImage;
+}
+exports.createSegmentTexture2d = createSegmentTexture2d;

package/lib/commonjs/mol-script/language/builder.d.ts

@@ -10,6 +10,7 @@ export declare namespace MolScriptBuilder {
         '@header': string;
         type: {
             '@header': string;
+            /** atom macromolecular property set */
             bool: MSymbol<import("./symbol").Arguments<import("./symbol").Arguments.PropTypes<{
                 0: import("./symbol").Argument<import("./type").Type.AnyValue>;
             }>>, import("./type").Type.OneOf<boolean>>;

package/lib/commonjs/mol-theme/color/volume-segment.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ColorTheme } from '../color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ThemeDataContext } from '../../mol-theme/theme';
+export declare const VolumeSegmentColorThemeParams: {
+    palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        maxCount: number;
+        hue: [number, number];
+        chroma: [number, number];
+        luminance: [number, number];
+        clusteringStepCount: number;
+        minSampleCount: number;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
+};
+export type VolumeSegmentColorThemeParams = typeof VolumeSegmentColorThemeParams;
+export declare function getVolumeSegmentColorThemeParams(ctx: ThemeDataContext): {
+    palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        maxCount: number;
+        hue: [number, number];
+        chroma: [number, number];
+        luminance: [number, number];
+        clusteringStepCount: number;
+        minSampleCount: number;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
+};
+export declare function VolumeSegmentColorTheme(ctx: ThemeDataContext, props: PD.Values<VolumeSegmentColorThemeParams>): ColorTheme<VolumeSegmentColorThemeParams>;
+export declare const VolumeSegmentColorThemeProvider: ColorTheme.Provider<VolumeSegmentColorThemeParams, 'volume-segment'>;

package/lib/commonjs/mol-theme/color/volume-segment.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumeSegmentColorThemeProvider = exports.VolumeSegmentColorTheme = exports.getVolumeSegmentColorThemeParams = exports.VolumeSegmentColorThemeParams = void 0;
+var tslib_1 = require("tslib");
+var color_1 = require("../../mol-util/color");
+var param_definition_1 = require("../../mol-util/param-definition");
+var palette_1 = require("../../mol-util/color/palette");
+var volume_1 = require("../../mol-model/volume/volume");
+var DefaultColor = (0, color_1.Color)(0xCCCCCC);
+var Description = 'Gives every volume segment a unique color.';
+exports.VolumeSegmentColorThemeParams = tslib_1.__assign({}, (0, palette_1.getPaletteParams)({ type: 'colors', colorList: 'many-distinct' }));
+function getVolumeSegmentColorThemeParams(ctx) {
+    return param_definition_1.ParamDefinition.clone(exports.VolumeSegmentColorThemeParams);
+}
+exports.getVolumeSegmentColorThemeParams = getVolumeSegmentColorThemeParams;
+function VolumeSegmentColorTheme(ctx, props) {
+    var color;
+    var legend;
+    var segmentation = ctx.volume && volume_1.Volume.Segmentation.get(ctx.volume);
+    if (segmentation) {
+        var size = segmentation.segments.size;
+        var segments_1 = Array.from(segmentation.segments.keys());
+        var palette_2 = (0, palette_1.getPalette)(size, props);
+        legend = palette_2.legend;
+        color = function (location) {
+            if (volume_1.Volume.Segment.isLocation(location)) {
+                return palette_2.color(segments_1.indexOf(location.segment));
+            }
+            return DefaultColor;
+        };
+    }
+    else {
+        color = function () { return DefaultColor; };
+    }
+    return {
+        factory: VolumeSegmentColorTheme,
+        granularity: 'instance',
+        color: color,
+        props: props,
+        description: Description,
+        legend: legend
+    };
+}
+exports.VolumeSegmentColorTheme = VolumeSegmentColorTheme;
+exports.VolumeSegmentColorThemeProvider = {
+    name: 'volume-segment',
+    label: 'Volume Segment',
+    category: "Miscellaneous" /* ColorTheme.Category.Misc */,
+    factory: VolumeSegmentColorTheme,
+    getParams: getVolumeSegmentColorThemeParams,
+    defaultValues: param_definition_1.ParamDefinition.getDefaultValues(exports.VolumeSegmentColorThemeParams),
+    isApplicable: function (ctx) { return !!ctx.volume && !!volume_1.Volume.Segmentation.get(ctx.volume); }
+};

package/lib/commonjs/mol-theme/color/volume-value.js

@@ -9,6 +9,7 @@ exports.VolumeValueColorThemeProvider = exports.VolumeValueColorTheme = exports.
 var color_1 = require("../../mol-util/color");
 var param_definition_1 = require("../../mol-util/param-definition");
 var names_1 = require("../../mol-util/color/names");
+var volume_1 = require("../../mol-model/volume/volume");
 var Description = 'Assign color based on the given value of a volume cell.';
 exports.VolumeValueColorThemeParams = {
     colorList: param_definition_1.ParamDefinition.ColorList({
@@ -50,5 +51,5 @@ exports.VolumeValueColorThemeProvider = {
     factory: VolumeValueColorTheme,
     getParams: getVolumeValueColorThemeParams,
     defaultValues: param_definition_1.ParamDefinition.getDefaultValues(exports.VolumeValueColorThemeParams),
-    isApplicable: function (ctx) { return !!ctx.volume; },
+    isApplicable: function (ctx) { return !!ctx.volume && !volume_1.Volume.Segmentation.get(ctx.volume); },
 };

package/lib/commonjs/mol-theme/color.d.ts

@@ -629,6 +629,21 @@ declare namespace ColorTheme {
         uniform: Provider<{
             value: PD.Color;
         }, "uniform", ColorType>;
+        'volume-segment': Provider<{
+            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                maxCount: number;
+                hue: [number, number];
+                chroma: [number, number];
+                luminance: [number, number];
+                clusteringStepCount: number;
+                minSampleCount: number;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
+        }, "volume-segment", ColorType>;
         'volume-value': Provider<{
             colorList: PD.ColorList;
         }, "volume-value", ColorType>;