molstar 3.26.0 → 3.28.0

package/lib/mol-repr/structure/visual/util/bond.js

@@ -2,6 +2,7 @@
  * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
  */
 import { __assign } from "tslib";
 import { BondType } from '../../../../mol-model/structure/model/types';
@@ -12,11 +13,12 @@ import { LinkCylinderParams, LinkLineParams } from './link';
 import { ObjectKeys } from '../../../../mol-util/type-helpers';
 import { EmptyLoci } from '../../../../mol-model/loci';
 import { Interval, OrderedSet, SortedArray } from '../../../../mol-data/int';
-import { isH, isHydrogen } from './common';
+import { isHydrogen } from './common';
 export var BondParams = {
     includeTypes: PD.MultiSelect(ObjectKeys(BondType.Names), PD.objectToOptions(BondType.Names)),
     excludeTypes: PD.MultiSelect([], PD.objectToOptions(BondType.Names)),
     ignoreHydrogens: PD.Boolean(false),
+    ignoreHydrogensVariant: PD.Select('all', PD.arrayToOptions(['all', 'non-polar'])),
     aromaticBonds: PD.Boolean(true, { description: 'Display aromatic bonds with dashes' }),
     multipleBonds: PD.Select('symmetric', PD.arrayToOptions(['off', 'symmetric', 'offset'])),
 };
@@ -30,11 +32,10 @@ export function ignoreBondType(include, exclude, f) {
 }
 export function makeIntraBondIgnoreTest(structure, unit, props) {
     var elements = unit.elements;
-    var atomicNumber = unit.model.atomicHierarchy.derived.atom.atomicNumber;
     var bonds = unit.bonds;
     var a = bonds.a, b = bonds.b, edgeProps = bonds.edgeProps;
     var _flags = edgeProps.flags;
-    var ignoreHydrogens = props.ignoreHydrogens, includeTypes = props.includeTypes, excludeTypes = props.excludeTypes;
+    var ignoreHydrogens = props.ignoreHydrogens, ignoreHydrogensVariant = props.ignoreHydrogensVariant, includeTypes = props.includeTypes, excludeTypes = props.excludeTypes;
     var include = BondType.fromNames(includeTypes);
     var exclude = BondType.fromNames(excludeTypes);
     var allBondTypes = BondType.isAll(include) && 0 /* BondType.Flag.None */ === exclude;
@@ -45,15 +46,25 @@ export function makeIntraBondIgnoreTest(structure, unit, props) {
     if (allBondTypes && !ignoreHydrogens && !child)
         return;
     return function (edgeIndex) {
-        return ((!!childUnit && !SortedArray.has(childUnit.elements, elements[a[edgeIndex]])) ||
-            (ignoreHydrogens && (isH(atomicNumber, elements[a[edgeIndex]]) || isH(atomicNumber, elements[b[edgeIndex]]))) ||
-            (!allBondTypes && ignoreBondType(include, exclude, _flags[edgeIndex])));
+        var aI = a[edgeIndex];
+        var bI = b[edgeIndex];
+        if ((!!childUnit && !SortedArray.has(childUnit.elements, elements[aI]))) {
+            return true;
+        }
+        if (!allBondTypes && ignoreBondType(include, exclude, _flags[edgeIndex])) {
+            return true;
+        }
+        if (!ignoreHydrogens)
+            return false;
+        if (isHydrogen(structure, unit, elements[aI], ignoreHydrogensVariant) || isHydrogen(structure, unit, elements[bI], ignoreHydrogensVariant))
+            return true;
+        return false;
     };
 }
 export function makeInterBondIgnoreTest(structure, props) {
     var bonds = structure.interUnitBonds;
     var edges = bonds.edges;
-    var ignoreHydrogens = props.ignoreHydrogens, includeTypes = props.includeTypes, excludeTypes = props.excludeTypes;
+    var ignoreHydrogens = props.ignoreHydrogens, ignoreHydrogensVariant = props.ignoreHydrogensVariant, includeTypes = props.includeTypes, excludeTypes = props.excludeTypes;
     var include = BondType.fromNames(includeTypes);
     var exclude = BondType.fromNames(excludeTypes);
     var allBondTypes = BondType.isAll(include) && 0 /* BondType.Flag.None */ === exclude;
@@ -75,7 +86,7 @@ export function makeInterBondIgnoreTest(structure, props) {
             var b = edges[edgeIndex];
             var uA = structure.unitMap.get(b.unitA);
             var uB = structure.unitMap.get(b.unitB);
-            if (isHydrogen(uA, uA.elements[b.indexA]) || isHydrogen(uB, uB.elements[b.indexB]))
+            if (isHydrogen(structure, uA, uA.elements[b.indexA], ignoreHydrogensVariant) || isHydrogen(structure, uB, uB.elements[b.indexB], ignoreHydrogensVariant))
                 return true;
         }
         if (!allBondTypes) {

package/lib/mol-repr/structure/visual/util/common.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
  */
 import { Unit, Structure, ElementIndex, StructureElement, ResidueIndex } from '../../../../mol-model/structure';
 import { TransformData } from '../../../../mol-geo/geometry/transform-data';
@@ -52,11 +53,13 @@ export declare function ensureReasonableResolution<T>(box: Box3D, props: {
 export declare function getConformation(unit: Unit): import("../../../../mol-model/structure/model/properties/atomic").AtomicConformation | import("../../../../mol-model/structure/model/properties/coarse").CoarseSphereConformation | import("../../../../mol-model/structure/model/properties/coarse").CoarseGaussianConformation;
 export declare const CommonSurfaceParams: {
     ignoreHydrogens: PD.BooleanParam;
+    ignoreHydrogensVariant: PD.Select<"all" | "non-polar">;
     traceOnly: PD.BooleanParam;
     includeParent: PD.BooleanParam;
 };
 export declare const DefaultCommonSurfaceProps: PD.Values<{
     ignoreHydrogens: PD.BooleanParam;
+    ignoreHydrogensVariant: PD.Select<"all" | "non-polar">;
     traceOnly: PD.BooleanParam;
     includeParent: PD.BooleanParam;
 }>;
@@ -83,6 +86,6 @@ export declare function getStructureConformationAndRadius(structure: Structure,
     boundary: import("../../../../mol-math/geometry/boundary").Boundary;
     radius: (index: number) => number;
 };
-export declare function isHydrogen(unit: Unit, element: ElementIndex): boolean;
+export declare function isHydrogen(structure: Structure, unit: Unit, element: ElementIndex, variant: 'all' | 'non-polar'): boolean;
 export declare function isH(atomicNumber: ArrayLike<number>, element: ElementIndex): boolean;
 export declare function isTrace(unit: Unit, element: ElementIndex): boolean;

package/lib/mol-repr/structure/visual/util/common.js

@@ -2,6 +2,7 @@
  * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
  */
 import { __assign } from "tslib";
 import { Unit, StructureElement } from '../../../../mol-model/structure';
@@ -14,6 +15,7 @@ import { fillSerial } from '../../../../mol-util/array';
 import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
 import { getBoundary } from '../../../../mol-math/geometry/boundary';
 import { Box3D } from '../../../../mol-math/geometry';
+import { hasPolarNeighbour } from '../../../../mol-model-props/computed/chemistry/functional-group';
 /** Return a Loci for the elements of a whole residue the elementIndex belongs to. */
 export function getResidueLoci(structure, unit, elementIndex) {
     var elements = unit.elements, model = unit.model;
@@ -125,6 +127,7 @@ export function getConformation(unit) {
 }
 export var CommonSurfaceParams = {
     ignoreHydrogens: PD.Boolean(false, { description: 'Whether or not to include hydrogen atoms in the surface calculation.' }),
+    ignoreHydrogensVariant: PD.Select('all', PD.arrayToOptions(['all', 'non-polar'])),
     traceOnly: PD.Boolean(false, { description: 'Whether or not to only use trace atoms in the surface calculation.' }),
     includeParent: PD.Boolean(false, { description: 'Include elements of the parent structure in surface calculation to get a surface patch of the current structure.' }),
 };
@@ -149,7 +152,7 @@ function filterUnitId(id, elements, indices) {
     }
 }
 export function getUnitConformationAndRadius(structure, unit, sizeTheme, props) {
-    var ignoreHydrogens = props.ignoreHydrogens, traceOnly = props.traceOnly, includeParent = props.includeParent;
+    var ignoreHydrogens = props.ignoreHydrogens, ignoreHydrogensVariant = props.ignoreHydrogensVariant, traceOnly = props.traceOnly, includeParent = props.includeParent;
     var rootUnit = includeParent ? structure.root.unitMap.get(unit.id) : unit;
     var differentRoot = includeParent && rootUnit !== unit;
     var _a = getConformation(rootUnit), x = _a.x, y = _a.y, z = _a.z;
@@ -164,7 +167,7 @@ export function getUnitConformationAndRadius(structure, unit, sizeTheme, props)
         var _id = [];
         for (var i = 0, il = elements.length; i < il; ++i) {
             var eI = elements[i];
-            if (ignoreHydrogens && isHydrogen(rootUnit, eI))
+            if (ignoreHydrogens && isHydrogen(structure, rootUnit, eI, ignoreHydrogensVariant))
                 continue;
             if (traceOnly && !isTrace(rootUnit, eI))
                 continue;
@@ -193,7 +196,7 @@ export function getUnitConformationAndRadius(structure, unit, sizeTheme, props)
     return { position: position, boundary: boundary, radius: radius };
 }
 export function getStructureConformationAndRadius(structure, sizeTheme, props) {
-    var ignoreHydrogens = props.ignoreHydrogens, traceOnly = props.traceOnly, includeParent = props.includeParent;
+    var ignoreHydrogens = props.ignoreHydrogens, ignoreHydrogensVariant = props.ignoreHydrogensVariant, traceOnly = props.traceOnly, includeParent = props.includeParent;
     var differentRoot = includeParent && !!structure.parent;
     var l = StructureElement.Location.create(structure.root);
     var _a = structure.boundary.sphere, center = _a.center, sphereRadius = _a.radius;
@@ -221,7 +224,7 @@ export function getStructureConformationAndRadius(structure, sizeTheme, props) {
             l.unit = unit;
             for (var j = 0, jl = elements.length; j < jl; ++j) {
                 var eI = elements[j];
-                if (ignoreHydrogens && isHydrogen(unit, eI))
+                if (ignoreHydrogens && isHydrogen(structure, unit, eI, ignoreHydrogensVariant))
                     continue;
                 if (traceOnly && !isTrace(unit, eI))
                     continue;
@@ -283,10 +286,11 @@ export function getStructureConformationAndRadius(structure, sizeTheme, props) {
     return { position: position, boundary: boundary, radius: radius };
 }
 var _H = AtomicNumbers['H'];
-export function isHydrogen(unit, element) {
+export function isHydrogen(structure, unit, element, variant) {
     if (Unit.isCoarse(unit))
         return false;
-    return unit.model.atomicHierarchy.derived.atom.atomicNumber[element] === _H;
+    return (unit.model.atomicHierarchy.derived.atom.atomicNumber[element] === _H &&
+        (variant === 'all' || !hasPolarNeighbour(structure, unit, SortedArray.indexOf(unit.elements, element))));
 }
 export function isH(atomicNumber, element) {
     return atomicNumber[element] === _H;

package/lib/mol-repr/structure/visual/util/element.d.ts

@@ -16,6 +16,7 @@ import { Spheres } from '../../../../mol-geo/geometry/spheres/spheres';
 import { StructureGroup } from './common';
 type ElementProps = {
     ignoreHydrogens: boolean;
+    ignoreHydrogensVariant: 'all' | 'non-polar';
     traceOnly: boolean;
 };
 export type ElementSphereMeshProps = {

package/lib/mol-repr/structure/visual/util/element.js

@@ -15,13 +15,12 @@ import { addSphere } from '../../../../mol-geo/geometry/mesh/builder/sphere';
 import { LocationIterator } from '../../../../mol-geo/util/location-iterator';
 import { Spheres } from '../../../../mol-geo/geometry/spheres/spheres';
 import { SpheresBuilder } from '../../../../mol-geo/geometry/spheres/spheres-builder';
-import { isTrace, isH } from './common';
+import { isTrace, isHydrogen } from './common';
 import { Sphere3D } from '../../../../mol-math/geometry';
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
 var v3add = Vec3.add;
 export function makeElementIgnoreTest(structure, unit, props) {
-    var ignoreHydrogens = props.ignoreHydrogens, traceOnly = props.traceOnly;
-    var atomicNumber = unit.model.atomicHierarchy.derived.atom.atomicNumber;
+    var ignoreHydrogens = props.ignoreHydrogens, ignoreHydrogensVariant = props.ignoreHydrogensVariant, traceOnly = props.traceOnly;
     var isCoarse = Unit.isCoarse(unit);
     var child = structure.child;
     var childUnit = child === null || child === void 0 ? void 0 : child.unitMap.get(unit.id);
@@ -31,7 +30,7 @@ export function makeElementIgnoreTest(structure, unit, props) {
         return;
     return function (element) {
         return ((!!childUnit && !SortedArray.has(childUnit.elements, element)) ||
-            (!isCoarse && ignoreHydrogens && isH(atomicNumber, element)) ||
+            (!isCoarse && ignoreHydrogens && isHydrogen(structure, unit, element, ignoreHydrogensVariant)) ||
             (traceOnly && !isTrace(unit, element)));
     };
 }

package/lib/mol-repr/structure/visual/util/gaussian.d.ts

@@ -11,6 +11,7 @@ import { WebGLContext } from '../../../../mol-gl/webgl/context';
 import { SizeTheme } from '../../../../mol-theme/size';
 export declare const GaussianDensityParams: {
     ignoreHydrogens: PD.BooleanParam;
+    ignoreHydrogensVariant: PD.Select<"all" | "non-polar">;
     traceOnly: PD.BooleanParam;
     includeParent: PD.BooleanParam;
     resolution: PD.Numeric;
@@ -19,6 +20,7 @@ export declare const GaussianDensityParams: {
 };
 export declare const DefaultGaussianDensityProps: PD.Values<{
     ignoreHydrogens: PD.BooleanParam;
+    ignoreHydrogensVariant: PD.Select<"all" | "non-polar">;
     traceOnly: PD.BooleanParam;
     includeParent: PD.BooleanParam;
     resolution: PD.Numeric;

package/lib/mol-repr/volume/direct-volume.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -17,11 +17,11 @@ import { Loci } from '../../mol-model/loci';
 import { PickingId } from '../../mol-geo/geometry/picking';
 export declare function createDirectVolume2d(ctx: RuntimeContext, webgl: WebGLContext, volume: Volume, directVolume?: DirectVolume): DirectVolume;
 export declare function createDirectVolume3d(ctx: RuntimeContext, webgl: WebGLContext, volume: Volume, directVolume?: DirectVolume): DirectVolume;
-export declare function createDirectVolume(ctx: VisualContext, volume: Volume, theme: Theme, props: PD.Values<DirectVolumeParams>, directVolume?: DirectVolume): Promise<DirectVolume>;
-export declare function getDirectVolumeLoci(pickingId: PickingId, volume: Volume, props: DirectVolumeProps, id: number): Volume.Cell.Loci | {
+export declare function createDirectVolume(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: PD.Values<DirectVolumeParams>, directVolume?: DirectVolume): Promise<DirectVolume>;
+export declare function getDirectVolumeLoci(pickingId: PickingId, volume: Volume, key: number, props: DirectVolumeProps, id: number): Volume.Cell.Loci | {
     kind: "empty-loci";
 };
-export declare function eachDirectVolume(loci: Loci, volume: Volume, props: DirectVolumeProps, apply: (interval: Interval) => boolean): boolean;
+export declare function eachDirectVolume(loci: Loci, volume: Volume, key: number, props: DirectVolumeProps, apply: (interval: Interval) => boolean): boolean;
 export declare const DirectVolumeParams: {
     quality: {
         isEssential: boolean;

package/lib/mol-repr/volume/direct-volume.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -68,7 +68,7 @@ export function createDirectVolume3d(ctx, webgl, volume, directVolume) {
     return DirectVolume.create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, volume.grid.stats, false, axisOrder, directVolume);
 }
 //
-export function createDirectVolume(ctx, volume, theme, props, directVolume) {
+export function createDirectVolume(ctx, volume, key, theme, props, directVolume) {
     return __awaiter(this, void 0, void 0, function () {
         var runtime, webgl;
         return __generator(this, function (_a) {
@@ -84,20 +84,22 @@ export function createDirectVolume(ctx, volume, theme, props, directVolume) {
 function getLoci(volume, props) {
     return Volume.Loci(volume);
 }
-export function getDirectVolumeLoci(pickingId, volume, props, id) {
+export function getDirectVolumeLoci(pickingId, volume, key, props, id) {
     var objectId = pickingId.objectId, groupId = pickingId.groupId;
     if (id === objectId) {
         return Volume.Cell.Loci(volume, Interval.ofSingleton(groupId));
     }
     return EmptyLoci;
 }
-export function eachDirectVolume(loci, volume, props, apply) {
+export function eachDirectVolume(loci, volume, key, props, apply) {
     return eachVolumeLoci(loci, volume, undefined, apply);
 }
 //
 export var DirectVolumeParams = __assign(__assign({}, DirectVolume.Params), { quality: __assign(__assign({}, DirectVolume.Params.quality), { isEssential: false }) });
 export function getDirectVolumeParams(ctx, volume) {
-    return PD.clone(DirectVolumeParams);
+    var params = PD.clone(DirectVolumeParams);
+    params.controlPoints.getVolume = function () { return volume; };
+    return params;
 }
 export function DirectVolumeVisual(materialId) {
     return VolumeVisual({
@@ -126,5 +128,5 @@ export var DirectVolumeRepresentationProvider = VolumeRepresentationProvider({
     defaultValues: PD.getDefaultValues(DirectVolumeParams),
     defaultColorTheme: { name: 'volume-value' },
     defaultSizeTheme: { name: 'uniform' },
-    isApplicable: function (volume) { return !Volume.isEmpty(volume); }
+    isApplicable: function (volume) { return !Volume.isEmpty(volume) && !Volume.Segmentation.get(volume); }
 });

package/lib/mol-repr/volume/isosurface.d.ts

@@ -41,7 +41,7 @@ export declare const VolumeIsosurfaceParams: {
 };
 export type VolumeIsosurfaceParams = typeof VolumeIsosurfaceParams;
 export type VolumeIsosurfaceProps = PD.Values<VolumeIsosurfaceParams>;
-export declare function IsosurfaceVisual(materialId: number, volume: Volume, props: PD.Values<IsosurfaceMeshParams>, webgl?: WebGLContext): VolumeVisual<{
+export declare function IsosurfaceVisual(materialId: number, volume: Volume, key: number, props: PD.Values<IsosurfaceMeshParams>, webgl?: WebGLContext): VolumeVisual<{
     quality: {
         isEssential: boolean;
         type: "select";
@@ -114,8 +114,8 @@ export declare function IsosurfaceVisual(materialId: number, volume: Volume, pro
     }>>;
     instanceGranularity: PD.BooleanParam;
 }>;
-export declare function eachIsosurface(loci: Loci, volume: Volume, props: VolumeIsosurfaceProps, apply: (interval: Interval) => boolean): boolean;
-export declare function createVolumeIsosurfaceMesh(ctx: VisualContext, volume: Volume, theme: Theme, props: VolumeIsosurfaceProps, mesh?: Mesh): Promise<Mesh>;
+export declare function eachIsosurface(loci: Loci, volume: Volume, key: number, props: VolumeIsosurfaceProps, apply: (interval: Interval) => boolean): boolean;
+export declare function createVolumeIsosurfaceMesh(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: VolumeIsosurfaceProps, mesh?: Mesh): Promise<Mesh>;
 export declare const IsosurfaceMeshParams: {
     quality: {
         isEssential: boolean;
@@ -192,7 +192,7 @@ export declare const IsosurfaceMeshParams: {
 export type IsosurfaceMeshParams = typeof IsosurfaceMeshParams;
 export declare function IsosurfaceMeshVisual(materialId: number): VolumeVisual<IsosurfaceMeshParams>;
 export declare function IsosurfaceTextureMeshVisual(materialId: number): VolumeVisual<IsosurfaceMeshParams>;
-export declare function createVolumeIsosurfaceWireframe(ctx: VisualContext, volume: Volume, theme: Theme, props: VolumeIsosurfaceProps, lines?: Lines): Promise<Lines>;
+export declare function createVolumeIsosurfaceWireframe(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: VolumeIsosurfaceProps, lines?: Lines): Promise<Lines>;
 export declare const IsosurfaceWireframeParams: {
     quality: {
         isEssential: boolean;

package/lib/mol-repr/volume/isosurface.js

@@ -41,7 +41,7 @@ function suitableForGpu(volume, webgl) {
     var powerOfTwoSize = getVolumeTexture2dLayout(gridDim, Padding).powerOfTwoSize;
     return powerOfTwoSize <= webgl.maxTextureSize / 2;
 }
-export function IsosurfaceVisual(materialId, volume, props, webgl) {
+export function IsosurfaceVisual(materialId, volume, key, props, webgl) {
     if (props.tryUseGpu && webgl && gpuSupport(webgl) && suitableForGpu(volume, webgl)) {
         return IsosurfaceTextureMeshVisual(materialId);
     }
@@ -50,7 +50,7 @@ export function IsosurfaceVisual(materialId, volume, props, webgl) {
 function getLoci(volume, props) {
     return Volume.Isosurface.Loci(volume, props.isoValue);
 }
-function getIsosurfaceLoci(pickingId, volume, props, id) {
+function getIsosurfaceLoci(pickingId, volume, key, props, id) {
     var objectId = pickingId.objectId, groupId = pickingId.groupId;
     if (id === objectId) {
         var granularity = Volume.PickingGranularity.get(volume);
@@ -66,11 +66,11 @@ function getIsosurfaceLoci(pickingId, volume, props, id) {
     }
     return EmptyLoci;
 }
-export function eachIsosurface(loci, volume, props, apply) {
-    return eachVolumeLoci(loci, volume, props.isoValue, apply);
+export function eachIsosurface(loci, volume, key, props, apply) {
+    return eachVolumeLoci(loci, volume, { isoValue: props.isoValue }, apply);
 }
 //
-export function createVolumeIsosurfaceMesh(ctx, volume, theme, props, mesh) {
+export function createVolumeIsosurfaceMesh(ctx, volume, key, theme, props, mesh) {
     return __awaiter(this, void 0, void 0, function () {
         var ids, surface, transform;
         return __generator(this, function (_a) {
@@ -96,7 +96,7 @@ export function createVolumeIsosurfaceMesh(ctx, volume, theme, props, mesh) {
                     else {
                         ValueCell.updateIfChanged(surface.varyingGroup, true);
                     }
-                    surface.setBoundingSphere(Volume.getBoundingSphere(volume));
+                    surface.setBoundingSphere(Volume.Isosurface.getBoundingSphere(volume, props.isoValue));
                     return [2 /*return*/, surface];
             }
         });
@@ -115,8 +115,8 @@ export function IsosurfaceMeshVisual(materialId) {
                 state.createGeometry = true;
         },
         geometryUtils: Mesh.Utils,
-        mustRecreate: function (volume, props, webgl) {
-            return props.tryUseGpu && !!webgl && suitableForGpu(volume, webgl);
+        mustRecreate: function (volumekey, props, webgl) {
+            return props.tryUseGpu && !!webgl && suitableForGpu(volumekey.volume, webgl);
         }
     }, materialId);
 }
@@ -157,9 +157,9 @@ var VolumeIsosurfaceTexture;
     }
     VolumeIsosurfaceTexture.get = get;
 })(VolumeIsosurfaceTexture || (VolumeIsosurfaceTexture = {}));
-function createVolumeIsosurfaceTextureMesh(ctx, volume, theme, props, textureMesh) {
+function createVolumeIsosurfaceTextureMesh(ctx, volume, key, theme, props, textureMesh) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, max, min, diff, value, isoLevel, _b, texture, gridDimension, gridTexDim, gridTexScale, transform, axisOrder, buffer, gv, groupCount, surface;
+        var _a, max, min, diff, value, isoLevel, _b, texture, gridDimension, gridTexDim, gridTexScale, transform, axisOrder, buffer, gv, groupCount, boundingSphere, surface;
         return __generator(this, function (_c) {
             if (!ctx.webgl)
                 throw new Error('webgl context required to create volume isosurface texture-mesh');
@@ -175,7 +175,8 @@ function createVolumeIsosurfaceTextureMesh(ctx, volume, theme, props, textureMes
             buffer = textureMesh === null || textureMesh === void 0 ? void 0 : textureMesh.doubleBuffer.get();
             gv = extractIsosurface(ctx.webgl, texture, gridDimension, gridTexDim, gridTexScale, transform, isoLevel, value < 0, 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 = TextureMesh.create(gv.vertexCount, groupCount, gv.vertexTexture, gv.groupTexture, gv.normalTexture, Volume.getBoundingSphere(volume), textureMesh);
+            boundingSphere = Volume.getBoundingSphere(volume);
+            surface = TextureMesh.create(gv.vertexCount, groupCount, gv.vertexTexture, gv.groupTexture, gv.normalTexture, boundingSphere, textureMesh);
             surface.meta.webgl = ctx.webgl;
             return [2 /*return*/, surface];
         });
@@ -193,8 +194,8 @@ export function IsosurfaceTextureMeshVisual(materialId) {
                 state.createGeometry = true;
         },
         geometryUtils: TextureMesh.Utils,
-        mustRecreate: function (volume, props, webgl) {
-            return !props.tryUseGpu || !webgl || !suitableForGpu(volume, webgl);
+        mustRecreate: function (volumeKey, props, webgl) {
+            return !props.tryUseGpu || !webgl || !suitableForGpu(volumeKey.volume, webgl);
         },
         dispose: function (geometry) {
             geometry.vertexTexture.ref.value.destroy();
@@ -205,7 +206,7 @@ export function IsosurfaceTextureMeshVisual(materialId) {
     }, materialId);
 }
 //
-export function createVolumeIsosurfaceWireframe(ctx, volume, theme, props, lines) {
+export function createVolumeIsosurfaceWireframe(ctx, volume, key, theme, props, lines) {
     return __awaiter(this, void 0, void 0, function () {
         var ids, wireframe, transform;
         return __generator(this, function (_a) {
@@ -222,7 +223,7 @@ export function createVolumeIsosurfaceWireframe(ctx, volume, theme, props, lines
                     wireframe = _a.sent();
                     transform = Grid.getGridToCartesianTransform(volume.grid);
                     Lines.transform(wireframe, transform);
-                    wireframe.setBoundingSphere(Volume.getBoundingSphere(volume));
+                    wireframe.setBoundingSphere(Volume.Isosurface.getBoundingSphere(volume, props.isoValue));
                     return [2 /*return*/, wireframe];
             }
         });
@@ -266,5 +267,5 @@ export var IsosurfaceRepresentationProvider = VolumeRepresentationProvider({
     defaultValues: PD.getDefaultValues(IsosurfaceParams),
     defaultColorTheme: { name: 'uniform' },
     defaultSizeTheme: { name: 'uniform' },
-    isApplicable: function (volume) { return !Volume.isEmpty(volume); }
+    isApplicable: function (volume) { return !Volume.isEmpty(volume) && !Volume.Segmentation.get(volume); }
 });

package/lib/mol-repr/volume/registry.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -199,6 +199,59 @@ export declare namespace VolumeRepresentationRegistry {
             }>>;
             instanceGranularity: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
         }, "direct-volume">;
+        segment: import("./representation").VolumeRepresentationProvider<{
+            visuals: import("../../mol-util/param-definition").ParamDefinition.MultiSelect<"segment">;
+            bumpFrequency: import("../../mol-util/param-definition").ParamDefinition.Numeric;
+            quality: {
+                isEssential: boolean;
+                type: "select";
+                options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+                cycle?: boolean | undefined;
+                isOptional?: boolean | undefined;
+                defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+                label?: string | undefined;
+                description?: string | undefined;
+                legend?: import("../../mol-util/legend").Legend | undefined;
+                fieldLabels?: {
+                    [name: string]: string;
+                } | undefined;
+                isHidden?: boolean | undefined;
+                shortLabel?: boolean | undefined;
+                twoColumns?: boolean | undefined;
+                category?: string | undefined;
+                hideIf?: ((currentGroup: any) => boolean) | undefined;
+                help?: ((value: any) => {
+                    description?: string | undefined;
+                    legend?: import("../../mol-util/legend").Legend | undefined;
+                }) | undefined;
+            };
+            tryUseGpu: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            segments: import("../../mol-util/param-definition").ParamDefinition.Converted<number[], string[]>;
+            doubleSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            flipSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            flatShaded: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            ignoreLight: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            xrayShaded: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+            transparentBackfaces: import("../../mol-util/param-definition").ParamDefinition.Select<string>;
+            bumpAmplitude: import("../../mol-util/param-definition").ParamDefinition.Numeric;
+            alpha: import("../../mol-util/param-definition").ParamDefinition.Numeric;
+            material: import("../../mol-util/param-definition").ParamDefinition.Group<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                metalness: number;
+                roughness: number;
+                bumpiness: number;
+            }>>;
+            clip: import("../../mol-util/param-definition").ParamDefinition.Group<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                variant: import("../../mol-util/clip").Clip.Variant;
+                objects: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                    type: any;
+                    invert: any;
+                    position: any;
+                    rotation: any;
+                    scale: any;
+                }>[];
+            }>>;
+            instanceGranularity: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
+        }, "segment">;
     };
     type _BuiltIn = typeof BuiltIn;
     export type BuiltIn = keyof _BuiltIn;

package/lib/mol-repr/volume/registry.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -9,6 +9,7 @@ import { IsosurfaceRepresentationProvider } from './isosurface';
 import { objectForEach } from '../../mol-util/object';
 import { SliceRepresentationProvider } from './slice';
 import { DirectVolumeRepresentationProvider } from './direct-volume';
+import { SegmentRepresentationProvider } from './segment';
 var VolumeRepresentationRegistry = /** @class */ (function (_super) {
     __extends(VolumeRepresentationRegistry, _super);
     function VolumeRepresentationRegistry() {
@@ -28,5 +29,6 @@ export { VolumeRepresentationRegistry };
         'isosurface': IsosurfaceRepresentationProvider,
         'slice': SliceRepresentationProvider,
         'direct-volume': DirectVolumeRepresentationProvider,
+        'segment': SegmentRepresentationProvider,
     };
 })(VolumeRepresentationRegistry || (VolumeRepresentationRegistry = {}));

package/lib/mol-repr/volume/representation.d.ts

@@ -15,16 +15,20 @@ import { Interval } from '../../mol-data/int';
 import { VisualUpdateState } from '../util';
 import { Representation, RepresentationProvider, RepresentationContext, RepresentationParamsGetter } from '../representation';
 import { WebGLContext } from '../../mol-gl/webgl/context';
-export interface VolumeVisual<P extends VolumeParams> extends Visual<Volume, P> {
+export type VolumeKey = {
+    volume: Volume;
+    key: number;
+};
+export interface VolumeVisual<P extends VolumeParams> extends Visual<VolumeKey, P> {
 }
 interface VolumeVisualBuilder<P extends VolumeParams, G extends Geometry> {
     defaultProps: PD.Values<P>;
-    createGeometry(ctx: VisualContext, volume: Volume, theme: Theme, props: PD.Values<P>, geometry?: G): Promise<G> | G;
-    createLocationIterator(volume: Volume): LocationIterator;
-    getLoci(pickingId: PickingId, volume: Volume, props: PD.Values<P>, id: number): Loci;
-    eachLocation(loci: Loci, volume: Volume, props: PD.Values<P>, apply: (interval: Interval) => boolean): boolean;
+    createGeometry(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: PD.Values<P>, geometry?: G): Promise<G> | G;
+    createLocationIterator(volume: Volume, key: number): LocationIterator;
+    getLoci(pickingId: PickingId, volume: Volume, key: number, props: PD.Values<P>, id: number): Loci;
+    eachLocation(loci: Loci, volume: Volume, key: number, props: PD.Values<P>, apply: (interval: Interval) => boolean): boolean;
     setUpdateState(state: VisualUpdateState, volume: Volume, newProps: PD.Values<P>, currentProps: PD.Values<P>, newTheme: Theme, currentTheme: Theme): void;
-    mustRecreate?: (volume: Volume, props: PD.Values<P>) => boolean;
+    mustRecreate?: (volumeKey: VolumeKey, props: PD.Values<P>) => boolean;
     dispose?: (geometry: G) => void;
 }
 interface VolumeVisualGeometryBuilder<P extends VolumeParams, G extends Geometry> extends VolumeVisualBuilder<P, G> {
@@ -56,5 +60,5 @@ export declare const VolumeParams: {
     instanceGranularity: PD.BooleanParam;
 };
 export type VolumeParams = typeof VolumeParams;
-export declare function VolumeRepresentation<P extends VolumeParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, P>, visualCtor: (materialId: number, volume: Volume, props: PD.Values<P>, webgl?: WebGLContext) => VolumeVisual<P>, getLoci: (volume: Volume, props: PD.Values<P>) => Loci): VolumeRepresentation<P>;
+export declare function VolumeRepresentation<P extends VolumeParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, P>, visualCtor: (materialId: number, volume: Volume, key: number, props: PD.Values<P>, webgl?: WebGLContext) => VolumeVisual<P>, getLoci: (volume: Volume, props: PD.Values<P>) => Loci, getKeys?: (props: PD.Values<P>) => ArrayLike<number>): VolumeRepresentation<P>;
 export {};