molstar 3.0.0-dev.4 → 3.0.0-dev.8

package/lib/mol-theme/clipping.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -69,18 +69,7 @@ function Clipping(layers) {
         }
         Groups.toNames = toNames;
     })(Groups = Clipping.Groups || (Clipping.Groups = {}));
-    /** Clip object types */
-    Clipping.Type = {
-        none: 0,
-        plane: 1,
-        sphere: 2,
-        cube: 3,
-        cylinder: 4,
-        infiniteCone: 5,
-    };
     function areEqual(cA, cB) {
-        if (cA.layers.length === 0 && cB.layers.length === 0)
-            return true;
         if (cA.layers.length !== cB.layers.length)
             return false;
         for (var i = 0, il = cA.layers.length; i < il; ++i) {
@@ -92,10 +81,12 @@ function Clipping(layers) {
         return true;
     }
     Clipping.areEqual = areEqual;
+    /** Check if layers empty */
     function isEmpty(clipping) {
         return clipping.layers.length === 0;
     }
     Clipping.isEmpty = isEmpty;
+    /** Remap layers */
     function remap(clipping, structure) {
         var layers = [];
         for (var _i = 0, _a = clipping.layers; _i < _a.length; _i++) {
@@ -109,6 +100,7 @@ function Clipping(layers) {
         return { layers: layers };
     }
     Clipping.remap = remap;
+    /** Merge layers */
     function merge(clipping) {
         if (isEmpty(clipping))
             return clipping;
@@ -133,6 +125,7 @@ function Clipping(layers) {
         return { layers: layers };
     }
     Clipping.merge = merge;
+    /** Filter layers */
     function filter(clipping, filter) {
         if (isEmpty(clipping))
             return clipping;

package/lib/mol-theme/color/volume-value.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2021 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 '../theme';
+export declare const VolumeValueColorThemeParams: {
+    colorList: PD.ColorList;
+};
+export declare type VolumeValueColorThemeParams = typeof VolumeValueColorThemeParams;
+export declare function getVolumeValueColorThemeParams(ctx: ThemeDataContext): {
+    colorList: PD.ColorList;
+};
+export declare function VolumeValueColorTheme(ctx: ThemeDataContext, props: PD.Values<VolumeValueColorThemeParams>): ColorTheme<VolumeValueColorThemeParams>;
+export declare const VolumeValueColorThemeProvider: ColorTheme.Provider<VolumeValueColorThemeParams, 'volume-value'>;

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

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Color, ColorScale } from '../../mol-util/color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ColorNames } from '../../mol-util/color/names';
+var DefaultColor = Color(0xCCCCCC);
+var Description = 'Assign color based on the given value of a volume cell.';
+export var VolumeValueColorThemeParams = {
+    colorList: PD.ColorList({
+        kind: 'interpolate',
+        colors: [
+            [ColorNames.white, 0],
+            [ColorNames.red, 0.25],
+            [ColorNames.white, 0.5],
+            [ColorNames.blue, 0.75],
+            [ColorNames.white, 1]
+        ]
+    }, { offsets: true, isEssential: true }),
+};
+export function getVolumeValueColorThemeParams(ctx) {
+    return VolumeValueColorThemeParams; // TODO return copy
+}
+export function VolumeValueColorTheme(ctx, props) {
+    var scale = ColorScale.create({ domain: [0, 1], listOrName: props.colorList.colors });
+    var colors = [];
+    for (var i = 0; i < 256; ++i) {
+        colors[i] = scale.color(i / 255);
+    }
+    var palette = { colors: colors, filter: 'linear' };
+    return {
+        factory: VolumeValueColorTheme,
+        granularity: 'direct',
+        color: function () { return DefaultColor; },
+        props: props,
+        description: Description,
+        legend: scale.legend,
+        palette: palette,
+    };
+}
+export var VolumeValueColorThemeProvider = {
+    name: 'volume-value',
+    label: 'Volume Value',
+    category: "Miscellaneous" /* Misc */,
+    factory: VolumeValueColorTheme,
+    getParams: getVolumeValueColorThemeParams,
+    defaultValues: PD.getDefaultValues(VolumeValueColorThemeParams),
+    isApplicable: function (ctx) { return !!ctx.volume; },
+};
+//# sourceMappingURL=volume-value.js.map

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

@@ -301,6 +301,9 @@ declare namespace ColorTheme {
         uniform: Provider<{
             value: PD.Color;
         }, "uniform">;
+        'volume-value': Provider<{
+            colorList: PD.ColorList;
+        }, "volume-value">;
     };
     type _BuiltIn = typeof BuiltIn;
     export type BuiltIn = keyof _BuiltIn;

package/lib/mol-theme/color.js

@@ -30,6 +30,7 @@ import { OperatorHklColorThemeProvider } from './color/operator-hkl';
 import { PartialChargeColorThemeProvider } from './color/partial-charge';
 import { AtomIdColorThemeProvider } from './color/atom-id';
 import { EntityIdColorThemeProvider } from './color/entity-id';
+import { VolumeValueColorThemeProvider } from './color/volume-value';
 export { ColorTheme };
 var ColorTheme;
 (function (ColorTheme) {
@@ -76,6 +77,7 @@ var ColorTheme;
         'uncertainty': UncertaintyColorThemeProvider,
         'unit-index': UnitIndexColorThemeProvider,
         'uniform': UniformColorThemeProvider,
+        'volume-value': VolumeValueColorThemeProvider,
     };
 })(ColorTheme || (ColorTheme = {}));
 export function ColorThemeProvider(p) { return p; }

package/lib/mol-util/clip.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Vec3 } from '../mol-math/linear-algebra';
+import { ParamDefinition as PD } from './param-definition';
+export interface Clip {
+    variant: Clip.Variant;
+    objects: Clip.Objects;
+}
+export declare function Clip(): void;
+export declare namespace Clip {
+    /** Clip object types */
+    const Type: {
+        none: number;
+        plane: number;
+        sphere: number;
+        cube: number;
+        cylinder: number;
+        infiniteCone: number;
+    };
+    type Variant = 'instance' | 'pixel';
+    type Objects = {
+        count: number;
+        type: number[];
+        invert: boolean[];
+        position: number[];
+        rotation: number[];
+        scale: number[];
+    };
+    const Params: {
+        variant: PD.Select<Variant>;
+        objects: PD.ObjectList<PD.Normalize<{
+            type: "none" | "sphere" | "cube" | "plane" | "cylinder" | "infiniteCone";
+            invert: boolean;
+            position: Vec3;
+            rotation: PD.Normalize<{
+                axis: any;
+                angle: any;
+            }>;
+            scale: Vec3;
+        }>>;
+    };
+    type Params = typeof Params;
+    type Props = PD.Values<Params>;
+    function getClip(props: Props, clip?: Clip): Clip;
+    function areEqual(cA: Clip, cB: Clip): boolean;
+}

package/lib/mol-util/clip.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Quat, Vec3 } from '../mol-math/linear-algebra';
+import { degToRad } from '../mol-math/misc';
+import { ParamDefinition as PD } from './param-definition';
+import { stringToWords } from './string';
+export function Clip() {
+}
+(function (Clip) {
+    /** Clip object types */
+    Clip.Type = {
+        none: 0,
+        plane: 1,
+        sphere: 2,
+        cube: 3,
+        cylinder: 4,
+        infiniteCone: 5,
+    };
+    Clip.Params = {
+        variant: PD.Select('pixel', PD.arrayToOptions(['instance', 'pixel'])),
+        objects: PD.ObjectList({
+            type: PD.Select('plane', PD.objectToOptions(Clip.Type, function (t) { return stringToWords(t); })),
+            invert: PD.Boolean(false),
+            position: PD.Vec3(Vec3()),
+            rotation: PD.Group({
+                axis: PD.Vec3(Vec3.create(1, 0, 0)),
+                angle: PD.Numeric(0, { min: -180, max: 180, step: 1 }, { description: 'Angle in Degrees' }),
+            }, { isExpanded: true }),
+            scale: PD.Vec3(Vec3.create(1, 1, 1)),
+        }, function (o) { return stringToWords(o.type); })
+    };
+    function createClipObjects() {
+        return {
+            count: 0,
+            type: (new Array(5)).fill(1),
+            invert: (new Array(5)).fill(false),
+            position: (new Array(5 * 3)).fill(0),
+            rotation: (new Array(5 * 4)).fill(0),
+            scale: (new Array(5 * 3)).fill(1),
+        };
+    }
+    var qA = Quat();
+    var qB = Quat();
+    var vA = Vec3();
+    var vB = Vec3();
+    function getClip(props, clip) {
+        var _a = (clip === null || clip === void 0 ? void 0 : clip.objects) || createClipObjects(), type = _a.type, invert = _a.invert, position = _a.position, rotation = _a.rotation, scale = _a.scale;
+        for (var i = 0, il = props.objects.length; i < il; ++i) {
+            var p = props.objects[i];
+            type[i] = Clip.Type[p.type];
+            invert[i] = p.invert;
+            Vec3.toArray(p.position, position, i * 3);
+            Quat.toArray(Quat.setAxisAngle(qA, p.rotation.axis, degToRad(p.rotation.angle)), rotation, i * 4);
+            Vec3.toArray(p.scale, scale, i * 3);
+        }
+        return {
+            variant: props.variant,
+            objects: { count: props.objects.length, type: type, invert: invert, position: position, rotation: rotation, scale: scale }
+        };
+    }
+    Clip.getClip = getClip;
+    function areEqual(cA, cB) {
+        if (cA.variant !== cB.variant)
+            return false;
+        if (cA.objects.count !== cB.objects.count)
+            return false;
+        var oA = cA.objects, oB = cB.objects;
+        for (var i = 0, il = oA.count; i < il; ++i) {
+            if (oA.invert[i] !== oB.invert[i])
+                return false;
+            if (oA.type[i] !== oB.type[i])
+                return false;
+            Vec3.fromArray(vA, oA.position, i * 3);
+            Vec3.fromArray(vB, oB.position, i * 3);
+            if (!Vec3.equals(vA, vB))
+                return false;
+            Vec3.fromArray(vA, oA.scale, i * 3);
+            Vec3.fromArray(vB, oB.scale, i * 3);
+            if (!Vec3.equals(vA, vB))
+                return false;
+            Quat.fromArray(qA, oA.rotation, i * 4);
+            Quat.fromArray(qB, oB.rotation, i * 4);
+            if (!Quat.equals(qA, qB))
+                return false;
+        }
+        return true;
+    }
+    Clip.areEqual = areEqual;
+})(Clip || (Clip = {}));
+//# sourceMappingURL=clip.js.map

package/lib/mol-util/number-packing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { NumberArray } from './type-helpers';
+/** encode positive integer as rgb byte triplet into array at offset */
+export declare function packIntToRGBArray(value: number, array: NumberArray, offset: number): NumberArray;
+/** decode positive integer encoded as rgb byte triplet */
+export declare function unpackRGBToInt(r: number, g: number, b: number): number;
+export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;

package/lib/mol-util/{float-packing.js → number-packing.js}

@@ -1,20 +1,13 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { clamp } from '../mol-math/interpolate';
-import { fasterExp, fasterLog } from '../mol-math/approx';
 import { Vec3, Vec4 } from '../mol-math/linear-algebra';
-var maxFloat = 10000.0; // NOTE same constant is set in shaders
-var floatLogFactor = fasterLog(maxFloat + 1);
-/** encode float logarithmically */
-export function encodeFloatLog(value) { return fasterLog(value + 1) / floatLogFactor; }
-/** decode logarithmically encoded float */
-export function decodeFloatLog(value) { return fasterExp(value * floatLogFactor) - 1; }
-/** encode float as rgb triplet into array at offset */
-export function encodeFloatRGBtoArray(value, array, offset) {
-    value = clamp(value, 0, 16777216 - 1) + 1;
+/** encode positive integer as rgb byte triplet into array at offset */
+export function packIntToRGBArray(value, array, offset) {
+    value = clamp(Math.round(value), 0, 16777216 - 1) + 1;
     array[offset + 2] = value % 256;
     value = Math.floor(value / 256);
     array[offset + 1] = value % 256;
@@ -22,8 +15,8 @@ export function encodeFloatRGBtoArray(value, array, offset) {
     array[offset] = value % 256;
     return array;
 }
-/** decode float encoded as rgb triplet */
-export function decodeFloatRGB(r, g, b) {
+/** decode positive integer encoded as rgb byte triplet */
+export function unpackRGBToInt(r, g, b) {
     return (Math.floor(r) * 256 * 256 + Math.floor(g) * 256 + Math.floor(b)) - 1;
 }
 var UnpackDownscale = 255 / 256; // 0..1 -> fraction (excluding 1)
@@ -34,4 +27,4 @@ export function unpackRGBAToDepth(r, g, b, a) {
     Vec4.set(tmpDepthRGBA, r / 255, g / 255, b / 255, a / 255);
     return Vec4.dot(tmpDepthRGBA, UnpackFactors);
 }
-//# sourceMappingURL=float-packing.js.map
+//# sourceMappingURL=number-packing.js.map