molstar 2.3.9 → 3.0.0-dev.10

package/lib/extensions/geo-export/obj-exporter.js

@@ -2,6 +2,7 @@
  * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { __awaiter, __extends, __generator } from "tslib";
 import { asciiWrite } from '../../mol-io/common/ascii';
@@ -42,7 +43,7 @@ var ObjExporter = /** @class */ (function (_super) {
         StringBuilder.newline(this.obj);
         if (!this.materialSet.has(material)) {
             this.materialSet.add(material);
-            var _a = Color.toRgbNormalized(color), r = _a[0], g = _a[1], b = _a[2];
+            var _a = Color.toRgbNormalized(color).map(function (v) { return Math.round(v * 1000) / 1000; }), r = _a[0], g = _a[1], b = _a[2];
             var mtl = this.mtl;
             StringBuilder.writeSafe(mtl, "newmtl ".concat(material, "\n"));
             StringBuilder.writeSafe(mtl, 'illum 2\n'); // illumination model
@@ -64,7 +65,7 @@ var ObjExporter = /** @class */ (function (_super) {
     };
     ObjExporter.prototype.addMeshWithColors = function (input) {
         return __awaiter(this, void 0, void 0, function () {
-            var mesh, values, isGeoTexture, webgl, ctx, obj, t, n, tmpV, stride, groupCount, colorType, uAlpha, dTransparency, tTransparency, aTransform, instanceCount, interpolatedColors, instanceIndex, _a, vertices, normals, indices, groups, vertexCount, drawCount, i, i, i, v, color, alpha, group, transparency, v1, v2, v3;
+            var mesh, values, isGeoTexture, webgl, ctx, obj, t, n, tmpV, stride, colorType, overpaintType, transparencyType, uAlpha, aTransform, instanceCount, interpolatedColors, interpolatedOverpaint, interpolatedTransparency, stride_1, instanceIndex, _a, vertices, normals, indices, groups, vertexCount, drawCount, i, i, geoData, quantizedColors, i, v, color, i, color, transparency, alpha, v1, v2, v3;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -74,16 +75,21 @@ var ObjExporter = /** @class */ (function (_super) {
                         n = Mat3();
                         tmpV = Vec3();
                         stride = isGeoTexture ? 4 : 3;
-                        groupCount = values.uGroupCount.ref.value;
                         colorType = values.dColorType.ref.value;
+                        overpaintType = values.dOverpaintType.ref.value;
+                        transparencyType = values.dTransparencyType.ref.value;
                         uAlpha = values.uAlpha.ref.value;
-                        dTransparency = values.dTransparency.ref.value;
-                        tTransparency = values.tTransparency.ref.value;
                         aTransform = values.aTransform.ref.value;
                         instanceCount = values.uInstanceCount.ref.value;
                         if (colorType === 'volume' || colorType === 'volumeInstance') {
-                            interpolatedColors = ObjExporter.getInterpolatedColors(mesh.vertices, mesh.vertexCount, values, stride, colorType, webgl);
-                            ObjExporter.quantizeColors(interpolatedColors, mesh.vertexCount);
+                            interpolatedColors = ObjExporter.getInterpolatedColors(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride, colorType: colorType });
+                        }
+                        if (overpaintType === 'volumeInstance') {
+                            interpolatedOverpaint = ObjExporter.getInterpolatedOverpaint(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride, colorType: overpaintType });
+                        }
+                        if (transparencyType === 'volumeInstance') {
+                            stride_1 = isGeoTexture ? 4 : 3;
+                            interpolatedTransparency = ObjExporter.getInterpolatedTransparency(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride_1, colorType: transparencyType });
                         }
                         return [4 /*yield*/, ctx.update({ isIndeterminate: false, current: 0, max: instanceCount })];
                     case 1:
@@ -124,16 +130,19 @@ var ObjExporter = /** @class */ (function (_super) {
                             StringBuilder.writeFloat(obj, tmpV[2], 100);
                             StringBuilder.newline(obj);
                         }
-                        // face
+                        geoData = { values: values, groups: groups, vertexCount: vertexCount, instanceIndex: instanceIndex, isGeoTexture: isGeoTexture };
+                        quantizedColors = new Uint8Array(drawCount * 3);
                         for (i = 0; i < drawCount; i += 3) {
                             v = isGeoTexture ? i : indices[i];
-                            color = ObjExporter.getColor(values, groups, vertexCount, instanceIndex, isGeoTexture, interpolatedColors, v);
-                            alpha = uAlpha;
-                            if (dTransparency) {
-                                group = isGeoTexture ? ObjExporter.getGroup(groups, i) : groups[indices[i]];
-                                transparency = tTransparency.array[instanceIndex * groupCount + group] / 255;
-                                alpha *= 1 - transparency;
-                            }
+                            color = ObjExporter.getColor(v, geoData, interpolatedColors, interpolatedOverpaint);
+                            Color.toArray(color, quantizedColors, i);
+                        }
+                        ObjExporter.quantizeColors(quantizedColors, vertexCount);
+                        // face
+                        for (i = 0; i < drawCount; i += 3) {
+                            color = Color.fromArray(quantizedColors, i);
+                            transparency = ObjExporter.getTransparency(i, geoData, interpolatedTransparency);
+                            alpha = Math.round(uAlpha * (1 - transparency) * 10) / 10;
                             this.updateMaterial(color, alpha);
                             v1 = this.vertexOffset + (isGeoTexture ? i : indices[i]) + 1;
                             v2 = this.vertexOffset + (isGeoTexture ? i + 1 : indices[i + 1]) + 1;

package/lib/extensions/geo-export/ui.js

@@ -17,37 +17,38 @@ var GeometryExporterUI = /** @class */ (function (_super) {
     function GeometryExporterUI() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         _this.save = function () { return __awaiter(_this, void 0, void 0, function () {
-            var data, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var data, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        _b.trys.push([0, 2, , 3]);
+                        _a.trys.push([0, 2, 3, 4]);
                         this.setState({ busy: true });
                         return [4 /*yield*/, this.controls.exportGeometry()];
                     case 1:
-                        data = _b.sent();
-                        this.setState({ busy: false });
+                        data = _a.sent();
                         download(data.blob, data.filename);
-                        return [3 /*break*/, 3];
+                        return [3 /*break*/, 4];
                     case 2:
-                        _a = _b.sent();
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [3 /*break*/, 4];
+                    case 3:
                         this.setState({ busy: false });
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         }); };
         _this.viewInAR = function () { return __awaiter(_this, void 0, void 0, function () {
-            var data, a_1, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var data, a_1, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        _b.trys.push([0, 2, , 3]);
+                        _a.trys.push([0, 2, 3, 4]);
                         this.setState({ busy: true });
                         return [4 /*yield*/, this.controls.exportGeometry()];
                     case 1:
-                        data = _b.sent();
-                        this.setState({ busy: false });
+                        data = _a.sent();
                         a_1 = document.createElement('a');
                         a_1.rel = 'ar';
                         a_1.href = URL.createObjectURL(data.blob);
@@ -56,12 +57,15 @@ var GeometryExporterUI = /** @class */ (function (_super) {
                         a_1.appendChild(document.createElement('img'));
                         setTimeout(function () { return URL.revokeObjectURL(a_1.href); }, 4E4); // 40s
                         setTimeout(function () { return a_1.dispatchEvent(new MouseEvent('click')); });
-                        return [3 /*break*/, 3];
+                        return [3 /*break*/, 4];
                     case 2:
-                        _a = _b.sent();
+                        e_2 = _a.sent();
+                        console.error(e_2);
+                        return [3 /*break*/, 4];
+                    case 3:
                         this.setState({ busy: false });
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         }); };

package/lib/extensions/geo-export/usdz-exporter.d.ts

@@ -2,8 +2,8 @@
  * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-import { Style } from '../../mol-gl/renderer';
 import { Box3D } from '../../mol-math/geometry';
 import { RuntimeContext } from '../../mol-task';
 import { MeshExporter, AddMeshInput } from './mesh-exporter';
@@ -11,18 +11,16 @@ export declare type UsdzData = {
     usdz: ArrayBuffer;
 };
 export declare class UsdzExporter extends MeshExporter<UsdzData> {
-    private style;
     readonly fileExtension = "usdz";
     private meshes;
     private materials;
-    private materialSet;
+    private materialMap;
     private centerTransform;
-    private static getMaterialKey;
     private addMaterial;
     protected addMeshWithColors(input: AddMeshInput): Promise<void>;
     getData(ctx: RuntimeContext): Promise<{
         usdz: ArrayBufferLike;
     }>;
     getBlob(ctx: RuntimeContext): Promise<Blob>;
-    constructor(style: Style, boundingBox: Box3D, radius: number);
+    constructor(boundingBox: Box3D, radius: number);
 }

package/lib/extensions/geo-export/usdz-exporter.js

@@ -2,6 +2,7 @@
  * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { __awaiter, __extends, __generator, __spreadArray } from "tslib";
 import { asciiWrite } from '../../mol-io/common/ascii';
@@ -18,13 +19,12 @@ var v3transformMat3 = Vec3.transformMat3;
 var mat3directionTransform = Mat3.directionTransform;
 var UsdzExporter = /** @class */ (function (_super) {
     __extends(UsdzExporter, _super);
-    function UsdzExporter(style, boundingBox, radius) {
+    function UsdzExporter(boundingBox, radius) {
         var _this = _super.call(this) || this;
-        _this.style = style;
         _this.fileExtension = 'usdz';
         _this.meshes = [];
         _this.materials = [];
-        _this.materialSet = new Set();
+        _this.materialMap = new Map();
         var t = Mat4();
         // scale the model so that it fits within 1 meter
         Mat4.fromUniformScaling(t, Math.min(1 / (radius * 2), 1));
@@ -33,20 +33,19 @@ var UsdzExporter = /** @class */ (function (_super) {
         _this.centerTransform = t;
         return _this;
     }
-    UsdzExporter.getMaterialKey = function (color, alpha) {
-        return color * 256 + Math.round(alpha * 255);
-    };
-    UsdzExporter.prototype.addMaterial = function (color, alpha) {
-        var materialKey = UsdzExporter.getMaterialKey(color, alpha);
-        if (this.materialSet.has(materialKey))
-            return;
-        this.materialSet.add(materialKey);
-        var _a = Color.toRgbNormalized(color), r = _a[0], g = _a[1], b = _a[2];
-        this.materials.push("\ndef Material \"material".concat(materialKey, "\"\n{\n    token outputs:surface.connect = </material").concat(materialKey, "/shader.outputs:surface>\n    def Shader \"shader\"\n    {\n        uniform token info:id = \"UsdPreviewSurface\"\n        color3f inputs:diffuseColor = (").concat(r, ",").concat(g, ",").concat(b, ")\n        float inputs:opacity = ").concat(alpha, "\n        float inputs:metallic = ").concat(this.style.metalness, "\n        float inputs:roughness = ").concat(this.style.roughness, "\n        token outputs:surface\n    }\n}\n"));
+    UsdzExporter.prototype.addMaterial = function (color, alpha, metalness, roughness) {
+        var hash = "".concat(color, "|").concat(alpha, "|").concat(metalness, "|").concat(roughness);
+        if (this.materialMap.has(hash))
+            return this.materialMap.get(hash);
+        var materialKey = this.materialMap.size;
+        this.materialMap.set(hash, materialKey);
+        var _a = Color.toRgbNormalized(color).map(function (v) { return Math.round(v * 1000) / 1000; }), r = _a[0], g = _a[1], b = _a[2];
+        this.materials.push("\ndef Material \"material".concat(materialKey, "\"\n{\n    token outputs:surface.connect = </material").concat(materialKey, "/shader.outputs:surface>\n    def Shader \"shader\"\n    {\n        uniform token info:id = \"UsdPreviewSurface\"\n        color3f inputs:diffuseColor = (").concat(r, ",").concat(g, ",").concat(b, ")\n        float inputs:opacity = ").concat(alpha, "\n        float inputs:metallic = ").concat(metalness, "\n        float inputs:roughness = ").concat(roughness, "\n        token outputs:surface\n    }\n}\n"));
+        return materialKey;
     };
     UsdzExporter.prototype.addMeshWithColors = function (input) {
         return __awaiter(this, void 0, void 0, function () {
-            var mesh, values, isGeoTexture, webgl, ctx, t, n, tmpV, stride, groupCount, colorType, uAlpha, dTransparency, tTransparency, aTransform, instanceCount, interpolatedColors, _loop_1, this_1, instanceIndex;
+            var mesh, values, isGeoTexture, webgl, ctx, t, n, tmpV, stride, colorType, overpaintType, transparencyType, uAlpha, aTransform, instanceCount, metalness, roughness, interpolatedColors, interpolatedOverpaint, stride_1, interpolatedTransparency, stride_2, _loop_1, this_1, instanceIndex;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -55,22 +54,30 @@ var UsdzExporter = /** @class */ (function (_super) {
                         n = Mat3();
                         tmpV = Vec3();
                         stride = isGeoTexture ? 4 : 3;
-                        groupCount = values.uGroupCount.ref.value;
                         colorType = values.dColorType.ref.value;
+                        overpaintType = values.dOverpaintType.ref.value;
+                        transparencyType = values.dTransparencyType.ref.value;
                         uAlpha = values.uAlpha.ref.value;
-                        dTransparency = values.dTransparency.ref.value;
-                        tTransparency = values.tTransparency.ref.value;
                         aTransform = values.aTransform.ref.value;
                         instanceCount = values.uInstanceCount.ref.value;
+                        metalness = values.uMetalness.ref.value;
+                        roughness = values.uRoughness.ref.value;
                         if (colorType === 'volume' || colorType === 'volumeInstance') {
-                            interpolatedColors = UsdzExporter.getInterpolatedColors(mesh.vertices, mesh.vertexCount, values, stride, colorType, webgl);
-                            UsdzExporter.quantizeColors(interpolatedColors, mesh.vertexCount);
+                            interpolatedColors = UsdzExporter.getInterpolatedColors(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride, colorType: colorType });
+                        }
+                        if (overpaintType === 'volumeInstance') {
+                            stride_1 = isGeoTexture ? 4 : 3;
+                            interpolatedOverpaint = UsdzExporter.getInterpolatedOverpaint(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride_1, colorType: overpaintType });
+                        }
+                        if (transparencyType === 'volumeInstance') {
+                            stride_2 = isGeoTexture ? 4 : 3;
+                            interpolatedTransparency = UsdzExporter.getInterpolatedTransparency(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride_2, colorType: transparencyType });
                         }
                         return [4 /*yield*/, ctx.update({ isIndeterminate: false, current: 0, max: instanceCount })];
                     case 1:
                         _a.sent();
                         _loop_1 = function (instanceIndex) {
-                            var _b, vertices, normals, indices, groups, vertexCount, drawCount, vertexBuilder, normalBuilder, indexBuilder, i, i, i, v, faceIndicesByMaterial, i, v, color, alpha, group, transparency, materialKey, faceIndices, materialBinding, materialKey, geomSubsets_1;
+                            var _b, vertices, normals, indices, groups, vertexCount, drawCount, vertexBuilder, normalBuilder, indexBuilder, i, i, geoData, i, v, quantizedColors, i, v, color, faceIndicesByMaterial, i, color, transparency, alpha, materialKey, faceIndices, materialBinding, materialKey, geomSubsets_1;
                             return __generator(this, function (_c) {
                                 switch (_c.label) {
                                     case 0:
@@ -109,6 +116,7 @@ var UsdzExporter = /** @class */ (function (_super) {
                                             StringBuilder.writeFloat(normalBuilder, tmpV[2], 100);
                                             StringBuilder.writeSafe(normalBuilder, ')');
                                         }
+                                        geoData = { values: values, groups: groups, vertexCount: vertexCount, instanceIndex: instanceIndex, isGeoTexture: isGeoTexture };
                                         // face
                                         for (i = 0; i < drawCount; ++i) {
                                             v = isGeoTexture ? i : indices[i];
@@ -116,18 +124,19 @@ var UsdzExporter = /** @class */ (function (_super) {
                                                 StringBuilder.writeSafe(indexBuilder, ',');
                                             StringBuilder.writeInteger(indexBuilder, v);
                                         }
-                                        faceIndicesByMaterial = new Map();
+                                        quantizedColors = new Uint8Array(drawCount * 3);
                                         for (i = 0; i < drawCount; i += 3) {
                                             v = isGeoTexture ? i : indices[i];
-                                            color = UsdzExporter.getColor(values, groups, vertexCount, instanceIndex, isGeoTexture, interpolatedColors, v);
-                                            alpha = uAlpha;
-                                            if (dTransparency) {
-                                                group = isGeoTexture ? UsdzExporter.getGroup(groups, i) : groups[indices[i]];
-                                                transparency = tTransparency.array[instanceIndex * groupCount + group] / 255;
-                                                alpha *= 1 - transparency;
-                                            }
-                                            this_1.addMaterial(color, alpha);
-                                            materialKey = UsdzExporter.getMaterialKey(color, alpha);
+                                            color = UsdzExporter.getColor(v, geoData, interpolatedColors, interpolatedOverpaint);
+                                            Color.toArray(color, quantizedColors, i);
+                                        }
+                                        UsdzExporter.quantizeColors(quantizedColors, vertexCount);
+                                        faceIndicesByMaterial = new Map();
+                                        for (i = 0; i < drawCount; i += 3) {
+                                            color = Color.fromArray(quantizedColors, i);
+                                            transparency = UsdzExporter.getTransparency(i, geoData, interpolatedTransparency);
+                                            alpha = Math.round(uAlpha * (1 - transparency) * 10) / 10;
+                                            materialKey = this_1.addMaterial(color, alpha, metalness, roughness);
                                             faceIndices = faceIndicesByMaterial.get(materialKey);
                                             if (faceIndices === undefined) {
                                                 faceIndices = [];

package/lib/extensions/model-archive/quality-assessment/behavior.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { PluginBehavior } from '../../../mol-plugin/behavior/behavior';
+import { StructureRepresentationPresetProvider } from '../../../mol-plugin-state/builder/structure/representation-preset';
+export declare const MAQualityAssessment: import("../../../mol-state/transformer").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, {
+    autoAttach: boolean;
+    showTooltip: boolean;
+}>;
+export declare const QualityAssessmentPLDDTPreset: StructureRepresentationPresetProvider<{
+    ignoreHydrogens: boolean | undefined;
+    quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
+    theme: PD.Normalize<{
+        globalName: any;
+        carbonColor: any;
+        symmetryColor: any;
+        focus: any;
+    }> | undefined;
+}, {
+    components?: undefined;
+    representations?: undefined;
+} | {
+    components: {
+        polymer: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>> | undefined;
+    };
+    representations: {
+        polymer: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure.Representation3D, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>>;
+    };
+} | {
+    components: {
+        all: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>> | undefined;
+        branched: undefined;
+    };
+    representations: {
+        all: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure.Representation3D, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>>;
+    };
+}>;
+export declare const QualityAssessmentQmeanPreset: StructureRepresentationPresetProvider<{
+    ignoreHydrogens: boolean | undefined;
+    quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
+    theme: PD.Normalize<{
+        globalName: any;
+        carbonColor: any;
+        symmetryColor: any;
+        focus: any;
+    }> | undefined;
+}, {
+    components?: undefined;
+    representations?: undefined;
+} | {
+    components: {
+        polymer: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>> | undefined;
+    };
+    representations: {
+        polymer: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure.Representation3D, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>>;
+    };
+} | {
+    components: {
+        all: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>> | undefined;
+        branched: undefined;
+    };
+    representations: {
+        all: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure.Representation3D, import("../../../mol-state/transformer").StateTransformer<import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, import("../../../mol-state/object").StateObject<any, import("../../../mol-state/object").StateObject.Type<any>>, any>>;
+    };
+}>;

package/lib/extensions/model-archive/quality-assessment/behavior.js

@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { PluginBehavior } from '../../../mol-plugin/behavior/behavior';
+import { DefaultQueryRuntimeTable } from '../../../mol-script/runtime/query/compiler';
+import { PLDDTConfidenceColorThemeProvider } from './color/plddt';
+import { QualityAssessment, QualityAssessmentProvider } from './prop';
+import { StructureSelectionCategory, StructureSelectionQuery } from '../../../mol-plugin-state/helpers/structure-selection-query';
+import { MolScriptBuilder as MS } from '../../../mol-script/language/builder';
+import { OrderedSet } from '../../../mol-data/int';
+import { cantorPairing } from '../../../mol-data/util';
+import { QmeanScoreColorThemeProvider } from './color/qmean';
+import { PresetStructureRepresentations, StructureRepresentationPresetProvider } from '../../../mol-plugin-state/builder/structure/representation-preset';
+import { StateObjectRef } from '../../../mol-state';
+export var MAQualityAssessment = PluginBehavior.create({
+    name: 'ma-quality-assessment-prop',
+    category: 'custom-props',
+    display: {
+        name: 'Quality Assessment',
+        description: 'Data included in Model Archive files.'
+    },
+    ctor: /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.provider = QualityAssessmentProvider;
+            _this.labelProvider = {
+                label: function (loci) {
+                    if (!_this.params.showTooltip)
+                        return;
+                    return [
+                        plddtLabel(loci),
+                        qmeanLabel(loci),
+                    ].filter(function (l) { return !!l; }).join('</br>');
+                }
+            };
+            return _this;
+        }
+        class_1.prototype.register = function () {
+            DefaultQueryRuntimeTable.addCustomProp(this.provider.descriptor);
+            this.ctx.customModelProperties.register(this.provider, this.params.autoAttach);
+            this.ctx.managers.lociLabels.addProvider(this.labelProvider);
+            this.ctx.representation.structure.themes.colorThemeRegistry.add(PLDDTConfidenceColorThemeProvider);
+            this.ctx.representation.structure.themes.colorThemeRegistry.add(QmeanScoreColorThemeProvider);
+            this.ctx.query.structure.registry.add(confidentPLDDT);
+            this.ctx.builders.structure.representation.registerPreset(QualityAssessmentPLDDTPreset);
+            this.ctx.builders.structure.representation.registerPreset(QualityAssessmentQmeanPreset);
+        };
+        class_1.prototype.update = function (p) {
+            var updated = this.params.autoAttach !== p.autoAttach;
+            this.params.autoAttach = p.autoAttach;
+            this.params.showTooltip = p.showTooltip;
+            this.ctx.customStructureProperties.setDefaultAutoAttach(this.provider.descriptor.name, this.params.autoAttach);
+            return updated;
+        };
+        class_1.prototype.unregister = function () {
+            DefaultQueryRuntimeTable.removeCustomProp(this.provider.descriptor);
+            this.ctx.customStructureProperties.unregister(this.provider.descriptor.name);
+            this.ctx.managers.lociLabels.removeProvider(this.labelProvider);
+            this.ctx.representation.structure.themes.colorThemeRegistry.remove(PLDDTConfidenceColorThemeProvider);
+            this.ctx.representation.structure.themes.colorThemeRegistry.remove(QmeanScoreColorThemeProvider);
+            this.ctx.query.structure.registry.remove(confidentPLDDT);
+            this.ctx.builders.structure.representation.unregisterPreset(QualityAssessmentPLDDTPreset);
+            this.ctx.builders.structure.representation.unregisterPreset(QualityAssessmentQmeanPreset);
+        };
+        return class_1;
+    }(PluginBehavior.Handler)),
+    params: function () { return ({
+        autoAttach: PD.Boolean(false),
+        showTooltip: PD.Boolean(true),
+    }); }
+});
+//
+function plddtCategory(score) {
+    if (score > 50 && score <= 70)
+        return 'Low';
+    if (score > 70 && score <= 90)
+        return 'Confident';
+    if (score > 90)
+        return 'Very high';
+    return 'Very low';
+}
+function plddtLabel(loci) {
+    return metricLabel(loci, 'pLDDT', function (scoreAvg, countInfo) { return "pLDDT Score ".concat(countInfo, ": ").concat(scoreAvg.toFixed(2), " <small>(").concat(plddtCategory(scoreAvg), ")</small>"); });
+}
+function qmeanLabel(loci) {
+    return metricLabel(loci, 'qmean', function (scoreAvg, countInfo) { return "QMEAN Score ".concat(countInfo, ": ").concat(scoreAvg.toFixed(2)); });
+}
+function metricLabel(loci, name, label) {
+    var _a;
+    if (loci.kind === 'element-loci') {
+        if (loci.elements.length === 0)
+            return;
+        var seen_1 = new Set();
+        var scoreSeen_1 = new Set();
+        var scoreSum_1 = 0;
+        var _loop_1 = function (indices, unit) {
+            var metric = (_a = QualityAssessmentProvider.get(unit.model).value) === null || _a === void 0 ? void 0 : _a[name];
+            if (!metric)
+                return "continue";
+            var residueIndex = unit.model.atomicHierarchy.residueAtomSegments.index;
+            var elements = unit.elements;
+            OrderedSet.forEach(indices, function (idx) {
+                var _a;
+                var eI = elements[idx];
+                var rI = residueIndex[eI];
+                var residueKey = cantorPairing(rI, unit.id);
+                if (!seen_1.has(residueKey)) {
+                    var score = (_a = metric.get(residueIndex[eI])) !== null && _a !== void 0 ? _a : -1;
+                    if (score !== -1) {
+                        scoreSum_1 += score;
+                        scoreSeen_1.add(residueKey);
+                    }
+                    seen_1.add(residueKey);
+                }
+            });
+        };
+        for (var _i = 0, _b = loci.elements; _i < _b.length; _i++) {
+            var _c = _b[_i], indices = _c.indices, unit = _c.unit;
+            _loop_1(indices, unit);
+        }
+        if (seen_1.size === 0)
+            return;
+        var summary = [];
+        if (scoreSeen_1.size) {
+            var countInfo = "<small>(".concat(scoreSeen_1.size, " ").concat(scoreSeen_1.size > 1 ? 'Residues avg.' : 'Residue', ")</small>");
+            var scoreAvg = scoreSum_1 / scoreSeen_1.size;
+            summary.push(label(scoreAvg, countInfo));
+        }
+        if (summary.length) {
+            return summary.join('</br>');
+        }
+    }
+}
+//
+var confidentPLDDT = StructureSelectionQuery('Confident pLDDT (> 70)', MS.struct.modifier.union([
+    MS.struct.modifier.wholeResidues([
+        MS.struct.modifier.union([
+            MS.struct.generator.atomGroups({
+                'chain-test': MS.core.rel.eq([MS.ammp('objectPrimitive'), 'atomistic']),
+                'residue-test': MS.core.rel.gr([QualityAssessment.symbols.pLDDT.symbol(), 70]),
+            })
+        ])
+    ])
+]), {
+    description: 'Select residues with a pLDDT > 70 (confident).',
+    category: StructureSelectionCategory.Validation,
+    ensureCustomProperties: function (ctx, structure) { return __awaiter(void 0, void 0, void 0, function () {
+        var _i, _a, m;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _i = 0, _a = structure.models;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < _a.length)) return [3 /*break*/, 4];
+                    m = _a[_i];
+                    return [4 /*yield*/, QualityAssessmentProvider.attach(ctx, m, void 0, true)];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }
+});
+//
+export var QualityAssessmentPLDDTPreset = StructureRepresentationPresetProvider({
+    id: 'preset-structure-representation-ma-quality-assessment-plddt',
+    display: {
+        name: 'Quality Assessment (pLDDT)', group: 'Annotation',
+        description: 'Color structure based on pLDDT Confidence.'
+    },
+    isApplicable: function (a) {
+        return !!a.data.models.some(function (m) { return QualityAssessment.isApplicable(m, 'pLDDT'); });
+    },
+    params: function () { return StructureRepresentationPresetProvider.CommonParams; },
+    apply: function (ref, params, plugin) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var structureCell, structure, colorTheme;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
+                        structure = (_a = structureCell === null || structureCell === void 0 ? void 0 : structureCell.obj) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!structureCell || !structure)
+                            return [2 /*return*/, {}];
+                        colorTheme = PLDDTConfidenceColorThemeProvider.name;
+                        return [4 /*yield*/, PresetStructureRepresentations.auto.apply(ref, __assign(__assign({}, params), { theme: { globalName: colorTheme, focus: { name: colorTheme } } }), plugin)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    }
+});
+export var QualityAssessmentQmeanPreset = StructureRepresentationPresetProvider({
+    id: 'preset-structure-representation-ma-quality-assessment-qmean',
+    display: {
+        name: 'Quality Assessment (QMEAN)', group: 'Annotation',
+        description: 'Color structure based on QMEAN Score.'
+    },
+    isApplicable: function (a) {
+        return !!a.data.models.some(function (m) { return QualityAssessment.isApplicable(m, 'qmean'); });
+    },
+    params: function () { return StructureRepresentationPresetProvider.CommonParams; },
+    apply: function (ref, params, plugin) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var structureCell, structure, colorTheme;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
+                        structure = (_a = structureCell === null || structureCell === void 0 ? void 0 : structureCell.obj) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!structureCell || !structure)
+                            return [2 /*return*/, {}];
+                        colorTheme = QmeanScoreColorThemeProvider.name;
+                        return [4 /*yield*/, PresetStructureRepresentations.auto.apply(ref, __assign(__assign({}, params), { theme: { globalName: colorTheme, focus: { name: colorTheme } } }), plugin)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    }
+});
+//# sourceMappingURL=behavior.js.map