molstar 3.26.0 → 3.28.0

package/lib/mol-io/reader/cif/schema/segmentation.js

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Column } from '../../../../mol-data/db';
+import { DensityServer_Data_Schema } from './density-server';
+var Schema = Column.Schema;
+var int = Schema.int;
+export var Segmentation_Data_Schema = {
+    volume_data_3d_info: DensityServer_Data_Schema.volume_data_3d_info,
+    segmentation_data_table: {
+        set_id: int,
+        segment_id: int,
+    },
+    segmentation_data_3d: {
+        values: int
+    }
+};

package/lib/mol-io/reader/cif.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -14,6 +14,7 @@ import { BIRD_Database } from './cif/schema/bird';
 import { dic_Database } from './cif/schema/dic';
 import { DensityServer_Data_Database } from './cif/schema/density-server';
 import { CifCore_Database } from './cif/schema/cif-core';
+import { Segmentation_Data_Database } from './cif/schema/segmentation';
 export declare const CIF: {
     parse: (data: string | Uint8Array) => import("../../mol-task/task").Task<import("./result").ReaderResult<import("./cif/data-model").CifFile>>;
     parseText: typeof parseCifText;
@@ -27,6 +28,7 @@ export declare const CIF: {
         dic: (frame: CifFrame) => dic_Database;
         cifCore: (frame: CifFrame) => CifCore_Database;
         densityServer: (frame: CifFrame) => DensityServer_Data_Database;
+        segmentation: (frame: CifFrame) => Segmentation_Data_Database;
     };
 };
 export * from './cif/data-model';

package/lib/mol-io/reader/cif.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -13,6 +13,7 @@ import { BIRD_Schema } from './cif/schema/bird';
 import { dic_Schema } from './cif/schema/dic';
 import { DensityServer_Data_Schema } from './cif/schema/density-server';
 import { CifCore_Schema, CifCore_Aliases } from './cif/schema/cif-core';
+import { Segmentation_Data_Schema } from './cif/schema/segmentation';
 export var CIF = {
     parse: function (data) { return typeof data === 'string' ? parseCifText(data) : parseCifBinary(data); },
     parseText: parseCifText,
@@ -26,6 +27,7 @@ export var CIF = {
         dic: function (frame) { return toDatabase(dic_Schema, frame); },
         cifCore: function (frame) { return toDatabase(CifCore_Schema, frame, CifCore_Aliases); },
         densityServer: function (frame) { return toDatabase(DensityServer_Data_Schema, frame); },
+        segmentation: function (frame) { return toDatabase(Segmentation_Data_Schema, frame); },
     }
 };
 export * from './cif/data-model';

package/lib/mol-model/location.d.ts

@@ -7,6 +7,7 @@ import { StructureElement } from './structure';
 import { Bond } from './structure/structure/unit/bonds';
 import { ShapeGroup } from './shape/shape';
 import { PositionLocation } from '../mol-geo/util/location-iterator';
+import { Volume } from './volume';
 /** A null value Location */
 export declare const NullLocation: {
     kind: "null-location";
@@ -22,4 +23,4 @@ export interface DataLocation<T = unknown, E = unknown> {
 }
 export declare function DataLocation<T = unknown, E = unknown>(tag: string, data: T, element: E): DataLocation<T, E>;
 export declare function isDataLocation(x: any): x is DataLocation;
-export type Location = StructureElement.Location | Bond.Location | ShapeGroup.Location | PositionLocation | DataLocation | NullLocation;
+export type Location = StructureElement.Location | Bond.Location | ShapeGroup.Location | PositionLocation | DataLocation | NullLocation | Volume.Segment.Location;

package/lib/mol-model/loci.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 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>
  */
@@ -39,7 +39,7 @@ export declare function areDataLociEqual(a: DataLoci, b: DataLoci): boolean;
 export declare function isDataLociEmpty(loci: DataLoci): boolean;
 export declare function DataLoci<T = unknown, E = unknown>(tag: string, data: T, elements: ReadonlyArray<E>, getBoundingSphere: DataLoci<T, E>['getBoundingSphere'], getLabel: DataLoci<T, E>['getLabel']): DataLoci<T, E>;
 export { Loci };
-type Loci = StructureElement.Loci | Structure.Loci | Bond.Loci | EveryLoci | EmptyLoci | DataLoci | Shape.Loci | ShapeGroup.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci;
+type Loci = StructureElement.Loci | Structure.Loci | Bond.Loci | EveryLoci | EmptyLoci | DataLoci | Shape.Loci | ShapeGroup.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci;
 declare namespace Loci {
     export interface Bundle<L extends number> {
         loci: FiniteArray<Loci, L>;
@@ -54,47 +54,47 @@ declare namespace Loci {
     export function getPrincipalAxes(loci: Loci): PrincipalAxes | undefined;
     const Granularity: {
         element: (loci: Loci) => Loci;
-        residue: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        residue: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        chain: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        chain: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        entity: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        entity: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        model: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        model: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        operator: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        operator: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        structure: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | {
+        structure: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci;
-        elementInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        elementInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        residueInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        residueInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";
         } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
-        chainInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        chainInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | Volume.Segment.Loci | {
             kind: "every-loci";
         } | {
             kind: "empty-loci";

package/lib/mol-model/loci.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 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>
  */
@@ -96,6 +96,9 @@ var Loci;
         if (Volume.Cell.isLoci(lociA) && Volume.Cell.isLoci(lociB)) {
             return Volume.Cell.areLociEqual(lociA, lociB);
         }
+        if (Volume.Segment.isLoci(lociA) && Volume.Segment.isLoci(lociB)) {
+            return Volume.Segment.areLociEqual(lociA, lociB);
+        }
         return false;
     }
     Loci.areEqual = areEqual;
@@ -126,6 +129,8 @@ var Loci;
             return Volume.Isosurface.isLociEmpty(loci);
         if (Volume.Cell.isLoci(loci))
             return Volume.Cell.isLociEmpty(loci);
+        if (Volume.Segment.isLoci(loci))
+            return Volume.Segment.isLociEmpty(loci);
         return false;
     }
     Loci.isEmpty = isEmpty;
@@ -177,6 +182,9 @@ var Loci;
         else if (loci.kind === 'cell-loci') {
             return Volume.Cell.getBoundingSphere(loci.volume, loci.indices, boundingSphere);
         }
+        else if (loci.kind === 'segment-loci') {
+            return Volume.Segment.getBoundingSphere(loci.volume, loci.segments, boundingSphere);
+        }
     }
     Loci.getBoundingSphere = getBoundingSphere;
     var tmpSphere3D = Sphere3D.zero();
@@ -222,6 +230,10 @@ var Loci;
             // TODO
             return void 0;
         }
+        else if (loci.kind === 'segment-loci') {
+            // TODO
+            return void 0;
+        }
     }
     Loci.getPrincipalAxes = getPrincipalAxes;
     //

package/lib/mol-model/sequence/alignment/sequence.d.ts

@@ -3,7 +3,7 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-import { StructureElement } from '../../structure/structure';
+import { StructureElement, Unit } from '../../structure/structure';
 import { AlignmentOptions } from './alignment';
 export { AlignSequences };
 declare namespace AlignSequences {
@@ -17,5 +17,8 @@ declare namespace AlignSequences {
         b: StructureElement.Loci.Element;
         score: number;
     };
+    function createSeqIdIndicesMap(element: StructureElement.Loci.Element): Map<number, StructureElement.UnitIndex[]>;
     function compute(input: Input, options?: Partial<AlignmentOptions>): Result;
 }
+export declare function entityKey(unit: Unit): import("../../structure").EntityIndex;
+export declare function getSequence(unit: Unit): import("../sequence").Sequence;

package/lib/mol-model/sequence/alignment/sequence.js

@@ -37,6 +37,7 @@ var AlignSequences;
         }
         return seqIds;
     }
+    AlignSequences.createSeqIdIndicesMap = createSeqIdIndicesMap;
     function compute(input, options) {
         if (options === void 0) { options = {}; }
         var seqA = getSequence(input.a.unit);
@@ -78,7 +79,7 @@ var AlignSequences;
     }
     AlignSequences.compute = compute;
 })(AlignSequences || (AlignSequences = {}));
-function entityKey(unit) {
+export function entityKey(unit) {
     switch (unit.kind) {
         case 0 /* Unit.Kind.Atomic */:
             return unit.model.atomicHierarchy.index.getEntityFromChain(unit.chainIndex[unit.elements[0]]);
@@ -88,6 +89,6 @@ function entityKey(unit) {
             return unit.model.coarseHierarchy.gaussians.entityKey[unit.elements[0]];
     }
 }
-function getSequence(unit) {
+export function getSequence(unit) {
     return unit.model.sequence.byEntityKey[entityKey(unit)].sequence;
 }

package/lib/mol-model/structure/model/properties/atomic/hierarchy.d.ts

@@ -147,6 +147,12 @@ export interface AtomicIndex {
      */
     findResidue(key: AtomicIndex.ResidueKey): ResidueIndex;
     findResidue(label_entity_id: string, label_asym_id: string, auth_seq_id: number, pdbx_PDB_ins_code?: string): ResidueIndex;
+    /**
+     * Index of the 1st occurence of this residue using "all-label" address.
+     * Doesn't work for "ligands" as they don't have a label seq id assigned.
+     * @returns index or -1 if not present.
+     */
+    findResidueLabel(key: AtomicIndex.ResidueLabelKey): ResidueIndex;
     /**
      * Index of the 1st occurence of this residue.
      * @param key.pdbx_PDB_ins_code Empty string for undefined

package/lib/mol-model/structure/model/properties/utils/atomic-index.js

@@ -97,6 +97,14 @@ var Index = /** @class */ (function () {
         var id = getResidueId(key.auth_seq_id, key.pdbx_PDB_ins_code || '');
         return rm.has(id) ? rm.get(id) : -1;
     };
+    Index.prototype.findResidueLabel = function (key) {
+        var cI = this.findChainLabel(key);
+        if (cI < 0)
+            return -1;
+        var rm = this.map.chain_index_label_seq_id.get(cI);
+        var id = getResidueId(key.label_seq_id, key.pdbx_PDB_ins_code || '');
+        return rm.has(id) ? rm.get(id) : -1;
+    };
     Index.prototype.findResidueAuth = function (key) {
         var cI = this.findChainAuth(key);
         if (cI < 0)

package/lib/mol-model/structure/structure/unit/bonds/inter-compute.js

@@ -107,8 +107,8 @@ function findPairBonds(unitA, unitB, props, builder) {
         var structConnEntries = props.forceCompute ? void 0 : structConn && structConn.byAtomIndex.get(aI);
         if (structConnEntries && structConnEntries.length) {
             var added = false;
-            for (var _i = 0, structConnEntries_1 = structConnEntries; _i < structConnEntries_1.length; _i++) {
-                var se = structConnEntries_1[_i];
+            for (var _g = 0, structConnEntries_1 = structConnEntries; _g < structConnEntries_1.length; _g++) {
+                var se = structConnEntries_1[_g];
                 var partnerA = se.partnerA, partnerB = se.partnerB;
                 var p = partnerA.atomIndex === aI ? partnerB : partnerA;
                 var _bI = SortedArray.indexOf(unitB.elements, p.atomIndex);
@@ -129,7 +129,7 @@ function findPairBonds(unitA, unitB, props, builder) {
             continue;
         var occA = occupancyA.value(aI);
         var lookup3d = unitB.lookup3d;
-        var _g = lookup3d.find(_imageA[0], _imageA[1], _imageA[2], maxRadius), indices = _g.indices, count = _g.count, squaredDistances = _g.squaredDistances;
+        var _h = lookup3d.find(_imageA[0], _imageA[1], _imageA[2], maxRadius), indices = _h.indices, count = _h.count, squaredDistances = _h.squaredDistances;
         if (count === 0)
             continue;
         var aeI = getElementIdx(type_symbolA.value(aI));
@@ -200,9 +200,25 @@ function computeInterUnitBonds(structure, props) {
             var mtB = b.model.atomicHierarchy.derived.residue.moleculeType;
             var notWater = ((!Unit.isAtomic(a) || mtA[a.residueIndex[a.elements[0]]] !== 2 /* MoleculeType.Water */) &&
                 (!Unit.isAtomic(b) || mtB[b.residueIndex[b.elements[0]]] !== 2 /* MoleculeType.Water */));
-            var notIon = ((!Unit.isAtomic(a) || mtA[a.residueIndex[a.elements[0]]] !== 3 /* MoleculeType.Ion */) &&
-                (!Unit.isAtomic(b) || mtB[b.residueIndex[b.elements[0]]] !== 3 /* MoleculeType.Ion */));
+            var sameModel = a.model === b.model;
+            var notIonA = (!Unit.isAtomic(a) || mtA[a.residueIndex[a.elements[0]]] !== 3 /* MoleculeType.Ion */) || (sameModel && hasStructConnRecord(a));
+            var notIonB = (!Unit.isAtomic(b) || mtB[b.residueIndex[b.elements[0]]] !== 3 /* MoleculeType.Ion */) || (sameModel && hasStructConnRecord(b));
+            var notIon = notIonA && notIonB;
             return Structure.validUnitPair(s, a, b) && (notWater || !p.ignoreWater) && (notIon || !p.ignoreIon);
         }) }));
 }
+function hasStructConnRecord(unit) {
+    if (!Unit.isAtomic(unit))
+        return false;
+    var elements = unit.elements;
+    var structConn = StructConn.Provider.get(unit.model);
+    if (structConn) {
+        for (var i = 0, _i = elements.length; i < _i; i++) {
+            if (structConn.byAtomIndex.get(elements[i])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 export { computeInterUnitBonds };

package/lib/mol-model/structure/structure/util/superposition.d.ts

@@ -11,4 +11,5 @@ type AlignAndSuperposeResult = MinimizeRmsd.Result & {
     alignmentScore: number;
 };
 export declare function alignAndSuperpose(xs: StructureElement.Loci[]): AlignAndSuperposeResult[];
+export declare function getPositionTable(xs: StructureElement.Loci, n: number): MinimizeRmsd.Positions;
 export {};

package/lib/mol-model/structure/structure/util/superposition.js

@@ -50,7 +50,7 @@ export function alignAndSuperpose(xs) {
     }
     return ret;
 }
-function getPositionTable(xs, n) {
+export function getPositionTable(xs, n) {
     var ret = MinimizeRmsd.Positions.empty(n);
     var o = 0;
     for (var _a = 0, _b = xs.elements; _a < _b.length; _a++) {

package/lib/mol-model/volume/volume.d.ts

@@ -4,8 +4,8 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { Grid } from './grid';
-import { OrderedSet } from '../../mol-data/int';
-import { Sphere3D } from '../../mol-math/geometry';
+import { OrderedSet, SortedArray } from '../../mol-data/int';
+import { Box3D, Sphere3D } from '../../mol-math/geometry';
 import { ModelFormat } from '../../mol-model-formats/format';
 import { CustomProperties } from '../custom-property';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
@@ -137,9 +137,42 @@ export declare namespace Volume {
         function isLociEmpty(loci: Loci): boolean;
         function getBoundingSphere(volume: Volume, indices: OrderedSet<CellIndex>, boundingSphere?: Sphere3D): Sphere3D;
     }
+    namespace Segment {
+        interface Loci {
+            readonly kind: 'segment-loci';
+            readonly volume: Volume;
+            readonly segments: SortedArray;
+        }
+        function Loci(volume: Volume, segments: ArrayLike<number>): Loci;
+        function isLoci(x: any): x is Loci;
+        function areLociEqual(a: Loci, b: Loci): boolean;
+        function isLociEmpty(loci: Loci): boolean;
+        function getBoundingSphere(volume: Volume, segments: ArrayLike<number>, boundingSphere?: Sphere3D): Sphere3D;
+        interface Location {
+            readonly kind: 'segment-location';
+            volume: Volume;
+            segment: number;
+        }
+        function Location(volume?: Volume, segment?: number): Location;
+        function isLocation(x: any): x is Location;
+    }
     type PickingGranularity = 'volume' | 'object' | 'voxel';
     const PickingGranularity: {
         set(volume: Volume, granularity: PickingGranularity): void;
         get(volume: Volume): PickingGranularity;
     };
+    type Segmentation = {
+        segments: Map<number, Set<number>>;
+        sets: Map<number, Set<number>>;
+        bounds: {
+            [k: number]: Box3D;
+        };
+        labels: {
+            [k: number]: string;
+        };
+    };
+    const Segmentation: {
+        set(volume: Volume, segmentation: Segmentation): void;
+        get(volume: Volume): Segmentation | undefined;
+    };
 }

package/lib/mol-model/volume/volume.js

@@ -4,8 +4,8 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { Grid } from './grid';
-import { OrderedSet } from '../../mol-data/int';
-import { Sphere3D } from '../../mol-math/geometry';
+import { OrderedSet, SortedArray } from '../../mol-data/int';
+import { Box3D, Sphere3D } from '../../mol-math/geometry';
 import { Vec3, Mat4 } from '../../mol-math/linear-algebra';
 import { BoundaryHelper } from '../../mol-math/geometry/boundary-helper';
 import { CubeFormat } from '../../mol-model-formats/volume/cube';
@@ -145,9 +145,38 @@ export var Volume;
         Isosurface.areLociEqual = areLociEqual;
         function isLociEmpty(loci) { return loci.volume.grid.cells.data.length === 0; }
         Isosurface.isLociEmpty = isLociEmpty;
+        var bbox = Box3D();
         function getBoundingSphere(volume, isoValue, boundingSphere) {
-            // TODO get bounding sphere for subgrid with values >= isoValue
-            return Volume.getBoundingSphere(volume, boundingSphere);
+            var value = Volume.IsoValue.toAbsolute(isoValue, volume.grid.stats).absoluteValue;
+            var neg = value < 0;
+            var c = [0, 0, 0];
+            var getCoords = volume.grid.cells.space.getCoords;
+            var d = volume.grid.cells.data;
+            var _a = volume.grid.cells.space.dimensions, xn = _a[0], yn = _a[1], zn = _a[2];
+            var minx = xn - 1, miny = yn - 1, minz = zn - 1;
+            var maxx = 0, maxy = 0, maxz = 0;
+            for (var i = 0, il = d.length; i < il; ++i) {
+                if ((neg && d[i] <= value) || (!neg && d[i] >= value)) {
+                    getCoords(i, c);
+                    if (c[0] < minx)
+                        minx = c[0];
+                    if (c[1] < miny)
+                        miny = c[1];
+                    if (c[2] < minz)
+                        minz = c[2];
+                    if (c[0] > maxx)
+                        maxx = c[0];
+                    if (c[1] > maxy)
+                        maxy = c[1];
+                    if (c[2] > maxz)
+                        maxz = c[2];
+                }
+            }
+            Vec3.set(bbox.min, minx - 1, miny - 1, minz - 1);
+            Vec3.set(bbox.max, maxx + 1, maxy + 1, maxz + 1);
+            var transform = Grid.getGridToCartesianTransform(volume.grid);
+            Box3D.transform(bbox, bbox, transform);
+            return Sphere3D.fromBox3D(boundingSphere || Sphere3D(), bbox);
         }
         Isosurface.getBoundingSphere = getBoundingSphere;
     })(Isosurface = Volume.Isosurface || (Volume.Isosurface = {}));
@@ -185,6 +214,44 @@ export var Volume;
         }
         Cell.getBoundingSphere = getBoundingSphere;
     })(Cell = Volume.Cell || (Volume.Cell = {}));
+    var Segment;
+    (function (Segment) {
+        function Loci(volume, segments) { return { kind: 'segment-loci', volume: volume, segments: SortedArray.ofUnsortedArray(segments) }; }
+        Segment.Loci = Loci;
+        function isLoci(x) { return !!x && x.kind === 'segment-loci'; }
+        Segment.isLoci = isLoci;
+        function areLociEqual(a, b) { return a.volume === b.volume && SortedArray.areEqual(a.segments, b.segments); }
+        Segment.areLociEqual = areLociEqual;
+        function isLociEmpty(loci) { return loci.volume.grid.cells.data.length === 0 || loci.segments.length === 0; }
+        Segment.isLociEmpty = isLociEmpty;
+        var bbox = Box3D();
+        function getBoundingSphere(volume, segments, boundingSphere) {
+            var segmentation = Volume.Segmentation.get(volume);
+            if (segmentation) {
+                Box3D.setEmpty(bbox);
+                for (var i = 0, il = segments.length; i < il; ++i) {
+                    var b = segmentation.bounds[segments[i]];
+                    Box3D.add(bbox, b.min);
+                    Box3D.add(bbox, b.max);
+                }
+                var transform = Grid.getGridToCartesianTransform(volume.grid);
+                Box3D.transform(bbox, bbox, transform);
+                return Sphere3D.fromBox3D(boundingSphere || Sphere3D(), bbox);
+            }
+            else {
+                return Volume.getBoundingSphere(volume, boundingSphere);
+            }
+        }
+        Segment.getBoundingSphere = getBoundingSphere;
+        function Location(volume, segment) {
+            return { kind: 'segment-location', volume: volume, segment: segment };
+        }
+        Segment.Location = Location;
+        function isLocation(x) {
+            return !!x && x.kind === 'segment-location';
+        }
+        Segment.isLocation = isLocation;
+    })(Segment = Volume.Segment || (Volume.Segment = {}));
     Volume.PickingGranularity = {
         set: function (volume, granularity) {
             volume._propertyData['__picking_granularity__'] = granularity;
@@ -194,4 +261,12 @@ export var Volume;
             return (_a = volume._propertyData['__picking_granularity__']) !== null && _a !== void 0 ? _a : 'voxel';
         }
     };
+    Volume.Segmentation = {
+        set: function (volume, segmentation) {
+            volume._propertyData['__segmentation__'] = segmentation;
+        },
+        get: function (volume) {
+            return volume._propertyData['__segmentation__'];
+        }
+    };
 })(Volume || (Volume = {}));

package/lib/mol-model-formats/volume/segmentation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Volume } from '../../mol-model/volume';
+import { Task } from '../../mol-task';
+import { ModelFormat } from '../format';
+import { Segmentation_Data_Database } from '../../mol-io/reader/cif/schema/segmentation';
+export declare function volumeFromSegmentationData(source: Segmentation_Data_Database, params?: Partial<{
+    label: string;
+    segmentLabels: {
+        [id: number]: string;
+    };
+    ownerId: string;
+}>): Task<Volume>;
+export { SegcifFormat };
+type SegcifFormat = ModelFormat<Segmentation_Data_Database>;
+declare namespace SegcifFormat {
+    function is(x?: ModelFormat): x is SegcifFormat;
+    function create(segcif: Segmentation_Data_Database): SegcifFormat;
+}