moorhen 0.6.7 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moorhen",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "private": false,
   "main": "moorhen.js",
   "types": "./types/main.d.ts",
@@ -62,7 +62,7 @@
       ]
     }
   },
-  "dependencies": { },
+  "dependencies": {},
   "scripts": {
     "create-version": "npx genversion -e -p ./package.json -d -s ./src/version.js",
     "transpile-ts-worker": "npx tsc --module es2015 --lib webworker --skipLibCheck public/baby-gru/CootWorker.ts && sed -i.bak '/export {}/d' public/baby-gru/CootWorker.js && rm public/baby-gru/CootWorker.js.bak",
@@ -142,7 +142,8 @@
     "gl-matrix": "^3.4.3",
     "html-react-parser": "^1.4.14",
     "html-webpack-plugin": "^5.5.0",
-    "iris-validation": "^0.1.8",
+    "iris-validation": "^0.1.10",
+    "iris-validation-backend": "^0.0.8",
     "jest": "^27.5.1",
     "jsdoc": "^4.0.2",
     "localforage": "^1.10.0",

package/types/libcoot.d.ts

@@ -12,17 +12,30 @@ declare global {
 
 export namespace libcootApi {
     type CCP4ModuleType = {
+        get_non_selected_cids(gemmiStructure: gemmi.Structure, cid: string): emscriptem.vector<string>;
+        parse_multi_cids(gemmiStructure: gemmi.Structure, cid: string): emscriptem.vector<string>;
+        parse_ligand_dict_info(fileContent: string): emscriptem.vector<{ comp_id: string; dict_contents: string; }>;
+        get_ligand_info_for_structure(gemmiStructure: gemmi.Structure): emscriptem.vector<{
+            resName: string;
+            chainName: string;
+            resNum: string;
+            modelName: string;
+            cid: string;
+        }>;
+        guess_coord_data_format(coordDataString: string): number;
+        get_structure_bfactors(gemmiStructure: gemmi.Structure): emscriptem.vector<{ cid: string; bFactor: number; normalised_bFactor }>;
         get_sequence_info(gemmiStructure: gemmi.Structure, molName: string): emscriptem.vector<SequenceEntry>;
         get_atom_info_for_selection(gemmiStructure: gemmi.Structure, arg1: string, arg2: string): emscriptem.vector<AtomInfo>;
         structure_is_ligand(gemmiStructure: gemmi.Structure): boolean;
         count_residues_in_selection(gemmiStructure: gemmi.Structure, selection: gemmi.Selection): number;
-        remove_non_selected_residues(gemmiStructure: gemmi.Structure, selection: gemmi.Selection): gemmi.Structure;
+        remove_non_selected_atoms(gemmiStructure: gemmi.Structure, selection: gemmi.Selection): gemmi.Structure;
         check_polymer_type(polymerConst: emscriptem.instance<number>): {value: number};
         remove_ligands_and_waters_chain(chain: gemmi.Chain): void;
         gemmi_setup_entities(gemmiStructure: gemmi.Structure): void;
+        gemmi_add_entity_types(gemmiStructure: gemmi.Structure, overWrite: boolean): void;
         remove_ligands_and_waters_structure(gemmiStructure: gemmi.Structure): void;
         remove_hydrogens_structure(gemmiStructure: gemmi.Structure): void;
-        read_structure_from_string(pdbData: string | ArrayBuffer, molName: string): gemmi.Structure;
+        read_structure_from_string(coordData: string | ArrayBuffer, molName: string): gemmi.Structure;
         get_mtz_columns(fileName: string): emscriptem.vector<string>;
         FS_createDataFile(arg0: string, fileName: string, byteArray: Uint8Array, arg3: boolean, arg4: boolean): void;
         getElementNameAsString: (arg0: emscriptem.instance<string>) => string;
@@ -66,7 +79,7 @@ export namespace libcootApi {
         res_name: string;
         label: string;
     }
-    interface AutoReadMtzInfo extends emscriptem.instance<AutoReadMtzInfo> {
+    interface AutoReadMtzInfo {
         idx: number;
         F: string;
         phi: string;
@@ -88,7 +101,7 @@ export namespace libcootApi {
         is_allowed_flag: boolean;
         residue_name: () => string;
     }
-    interface InterestingPlaceT extends emscriptem.instance<InterestingPlaceT> {
+    interface InterestingPlaceT {
         feature_type: string;
         residue_spec: ResidueSpecT;
         x: number;
@@ -203,7 +216,7 @@ export namespace libcootApi {
         amplitude: () => number;
         size: number;
     }
-    interface Generic3dLinesBondsBoxT extends emscriptem.instance<Generic3dLinesBondsBoxT> {
+    interface Generic3dLinesBondsBoxT {
         line_segments: emscriptem.vector<emscriptem.vector<CootCartesianPair>>;
     }
     type Generic3dLinesBondsBoxJS = {
@@ -217,20 +230,20 @@ export namespace libcootApi {
         status: string;
         richardson_probability: number;
     }
-    interface SimpleMeshT extends emscriptem.instance<SimpleMeshT> {
+    interface SimpleMeshT {
         vertices: emscriptem.vector<VncVertex>;
         triangles: emscriptem.vector<gTriangle>;
     }
     interface SimpleMeshJS {
         prim_types: [[string]];
         useIndices?: [[boolean]];
-        idx_tri: [[number[]]];
-        vert_tri: [[number[]]];
-        additional_norm_tri?: [[number[]]];
-        norm_tri: [[number[]]];
-        col_tri: [[number[]]];
+        idx_tri: [[number[]|Uint32Array]];
+        vert_tri: [[number[]|Float32Array]];
+        additional_norm_tri?: [[number[]|Float32Array]];
+        norm_tri: [[number[]|Float32Array]];
+        col_tri: [[number[]|Float32Array]];
     }
-    interface SymmetryData extends emscriptem.instance<SymmetryData> {
+    interface SymmetryData {
         cell: CellTranslation;
         symm_trans: emscriptem.vector<PairType<SymmetryTransT, CellTranslation>>;
     }
@@ -270,7 +283,7 @@ export namespace libcootApi {
         suggested_contour_level: number;
         suggested_radius: number;
     }
-    interface ResidueSpecT extends emscriptem.instance<ResidueSpecT> {
+    interface ResidueSpecT {
         model_number: number;
         chain_id: string;
         res_no: number;
@@ -282,7 +295,7 @@ export namespace libcootApi {
         modelNumber: number;
         chainId: string;
     }
-    interface AtomSpecT extends emscriptem.instance<ResidueSpecT> {
+    interface AtomSpecT {
         chain_id: string;
         res_no: number;
         ins_code: string;
@@ -304,12 +317,12 @@ export namespace libcootApi {
         string_user_data: string;
         model_number: number;
     }
-    interface ResidueValidationInformationT extends emscriptem.instance<ResidueValidationInformationT> {
+    interface ResidueValidationInformationT {
         label: string;
         residue_spec: ResidueSpecT;
         function_value: number;
     }
-    interface ChainValidationInformationT extends emscriptem.instance<ChainValidationInformationT> {
+    interface ChainValidationInformationT {
         chain_id: string;
         rviv: emscriptem.vector<ResidueValidationInformationT>;
     }
@@ -339,28 +352,28 @@ export namespace libcootApi {
         supperposeInfo: string,
         alignedPairsData: {reference: ValidationInformationJS, moving: ValidationInformationJS}[],
     }
-    interface InstancedDataType extends emscriptem.instance<InstancedDataType> {
+    type InstancedDataType = {
         position: [number, number, number];
         size: [number, number, number];
         colour: [number, number, number, number];
         orientation: [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
     }
-    interface gTriangle extends emscriptem.instance<gTriangle> {
+    interface gTriangle {
         point_id: [number, number, number];
     }
-    interface VncVertex extends emscriptem.instance<VncVertex> {
+    interface VncVertex {
         pos: [number, number, number];
         normal: [number, number, number];
         color: [number, number, number, number];
     }
-    interface InstancedGeomT extends emscriptem.instance<InstancedGeomT> {
+    interface InstancedGeomT {
         vertices: emscriptem.vector<VncVertex>;
         triangles: emscriptem.vector<gTriangle>;
         name: string;
         instancing_data_A: emscriptem.vector<InstancedDataType>;
         instancing_data_B: emscriptem.vector<InstancedDataType>;
     }
-    interface InstancedMeshT extends emscriptem.instance<InstancedMeshT> {
+    interface InstancedMeshT {
         geom: emscriptem.vector<InstancedGeomT>;
         markup: SimpleMeshT;
     }
@@ -410,6 +423,11 @@ export namespace libcootApi {
         psi: number;
         is_pre_pro: boolean;
     }
+    type fitLigandInfo = {
+        imol: number;
+        cluster_idx: number;
+        ligand_idx: number;
+    }
     type CootModule = {
         SmilesToPDB(arg0: string, arg1: string, arg2: number, arg3: number): PairType<string, string>;
         FS: {
@@ -419,6 +437,25 @@ export namespace libcootApi {
         FS_unlink(tempFilename: string): void;
         FS_createDataFile(arg0: string, arg1: string, arg2: Uint8Array | string, arg3: boolean, arg4: boolean, arg5?: boolean): void;
         molecules_container_js: { new(verbose: boolean): MoleculesContainerJS };
+        testFloat32Array( arg0: any ): Float32Array;
+        getPositionsFromSimpleMesh( arg0: any ): Float32Array;
+        getNormalsFromSimpleMesh( arg0: any ): Float32Array;
+        getReversedNormalsFromSimpleMesh( arg0: any ): Float32Array;
+        getColoursFromSimpleMesh( arg0: any ): Float32Array;
+
+        getPositionsFromSimpleMesh2( arg0: any, arg1: any ): void;
+        getNormalsFromSimpleMesh2( arg0: any, arg1: any ): void;
+        getReversedNormalsFromSimpleMesh2( arg0: any, arg1: any ): void;
+        getColoursFromSimpleMesh2( arg0: any, arg1: any ): void;
+
+        getLineIndicesFromSimpleMesh( arg0: any ): Uint32Array;
+        getPermutedTriangleIndicesFromSimpleMesh( arg0: any ): Uint32Array;
+        getTriangleIndicesFromSimpleMesh( arg0: any ): Uint32Array;
+
+        getLineIndicesFromSimpleMesh2( arg0: any, arg1: any  ): void;
+        getPermutedTriangleIndicesFromSimpleMesh2( arg0: any, arg1: any ): void;
+        getTriangleIndicesFromSimpleMesh2( arg0: any, arg1: any ): void;
+
         Vectormoved_residue_t: { new(): emscriptem.vector<MovedResidueT>};
         moved_residue_t: { new(arg0: string, arg1: number, arg2: string): MovedResidueT};
         moved_atom_t: { new(arg0: string, arg1: string, arg2: number, arg3: number, arg4: number, arg5: number): MovedAtomT};
@@ -427,6 +464,8 @@ export namespace libcootApi {
         getRamachandranData(arg0: string, arg1: string): emscriptem.vector<RamaData>
     }
     interface MoleculesContainerJS {
+        set_max_number_of_threads(arg0: number): void;
+        set_map_is_contoured_with_thread_pool(arg0: boolean): void;
         close_molecule(molNo: number): number;
         copy_fragment_using_residue_range(molNo: number, chainId: string, res_no_start: number, res_no_end: number): number;
         writeCCP4Map(molNo: number, tempFilename: string): void;

package/types/main.d.ts

@@ -2,7 +2,6 @@ import { moorhen as _moorhen } from "./moorhen"
 import { webGL } from "./mgWebGL";
 import { libcootApi } from "./libcoot";
 import { gemmi } from "./gemmi";
-import { emscriptem } from "./emscriptem";
 
 declare module 'moorhen' {
 
@@ -50,6 +49,8 @@ declare module 'moorhen' {
 
     class MoorhenMolecule implements _moorhen.Molecule {
         constructor(commandCentre: React.RefObject<_moorhen.CommandCentre>, glRef: React.RefObject<webGL.MGWebGL>, monomerLibrary: string)
+        getNonSelectedCids(cid: string): string[];
+        parseCidIntoSelection(selectedCid: string): Promise<_moorhen.ResidueSelection>;
         animateRefine(n_cyc: number, n_iteration: number, final_n_cyc?: number): Promise<void>;
         refineResidueRange(chainId: string, start: number, stop: number, ncyc?: number, redraw?: boolean): Promise<void>;
         SSMSuperpose(movChainId: string, refMolNo: number, refChainId: string): Promise<_moorhen.WorkerResponse>;
@@ -82,18 +83,20 @@ declare module 'moorhen' {
         generateSelfRestraints(cid?: string, maxRadius?: number): Promise<void>;
         clearExtraRestraints(): Promise<_moorhen.WorkerResponse>;
         refineResiduesUsingAtomCid(cid: string, mode: string, ncyc?: number, redraw?: boolean): Promise<void>;
+        getNcsRelatedChains(): Promise<string[][]>;
+        getResidueBFactors(): { cid: string; bFactor: number; normalised_bFactor: number }[];
         redo(): Promise<void>;
         undo(): Promise<void>;
         show(style: string, cid?: string): void;
         setSymmetryRadius(radius: number): Promise<void>;
         drawSymmetry: (fetchSymMatrix?: boolean) => Promise<void>;
         getUnitCellParams():  { a: number; b: number; c: number; alpha: number; beta: number; gamma: number; };
-        replaceModelWithFile(fileUrl: string, molName: string): Promise<void>
+        replaceModelWithFile(fileUrl: string): Promise<void>
         delete(): Promise<_moorhen.WorkerResponse> 
         fetchDefaultColourRules(): Promise<void>;
         fetchIfDirtyAndDraw(arg0: string): Promise<void>;
         drawEnvironment: (cid: string, labelled?: boolean) => Promise<void>;
-        centreOn: (selectionCid?: string, animate?: boolean) => Promise<void>;
+        centreOn: (selectionCid?: string, animate?: boolean, setZoom?: boolean) => Promise<void>;
         drawHover: (cid: string) => Promise<void>;
         drawResidueSelection: (cid: string) => Promise<void>;
         clearBuffersOfStyle: (style: string) => void;
@@ -103,17 +106,17 @@ declare module 'moorhen' {
         hide: (style: string, cid?: string) => void;
         redraw: () => Promise<void>;
         setAtomsDirty: (newVal: boolean) => void;
-        hasVisibleBuffers: (excludeBuffers?: string[]) => boolean;
+        isVisible: (excludeBuffers?: string[]) => boolean;
         centreAndAlignViewOn(selectionCid: string, animate?: boolean): Promise<void>;
         buffersInclude: (bufferIn: { id: string; }) => boolean;
         redrawRepresentation: (id: string) => Promise<void>;
+        downloadAtoms(format?: 'mmcif' | 'pdb'): Promise<void>;
         isLigand: boolean;
         type: string;
         excludedCids: string[];
         commandCentre: React.RefObject<_moorhen.CommandCentre>;
         glRef: React.RefObject<webGL.MGWebGL>;
         atomsDirty: boolean;
-        isVisible: boolean;
         name: string;
         molNo: number;
         gemmiStructure: gemmi.Structure;
@@ -131,6 +134,7 @@ declare module 'moorhen' {
             countourLevel: number;
             boxRadius: number;
             gridScale: number;
+            bFactor: number;
         };
         isDarkBackground: boolean;
         representations: _moorhen.MoleculeRepresentation[];
@@ -146,6 +150,7 @@ declare module 'moorhen' {
         selectionRepresentation: _moorhen.MoleculeRepresentation;
         hasDNA: boolean;
         hasGlycans: boolean;
+        coordsFormat: _moorhen.coorFormats;
     }
     module.exports.MoorhenMolecule = MoorhenMolecule
     
@@ -154,21 +159,30 @@ declare module 'moorhen' {
         getHistogram(nBins?: number, zoomFactor?: number): Promise<libcootApi.HistogramInfoJS>;
         setMapWeight(weight?: number): Promise<_moorhen.WorkerResponse>;
         estimateMapWeight(): Promise<void>;
-        setAlpha(alpha: number, redraw?: boolean): Promise<void>;
+        fetchMapAlphaAndRedraw(): Promise<void>;
         centreOnMap(): Promise<void>;
         getSuggestedSettings(): Promise<void>;
-        duplicate(): Promise<_moorhen.Map>;
-        makeCootUnlive(): void;
-        makeCootLive(): void;
-        setColour(r: number, g: number, b: number, redraw?: boolean): Promise<void> ;
-        setDiffMapColour(type: 'positiveDiffColour' | 'negativeDiffColour', r: number, g: number, b: number, redraw?: boolean): Promise<void> ;
+        copyMap(): Promise<_moorhen.Map>;
+        hideMapContour(): void;
+        drawMapContour(): Promise<void>;
+        getMapContourParams(): { 
+            mapRadius: number; 
+            contourLevel: number; 
+            mapAlpha: number; 
+            mapStyle: "lines" | "solid" | "lit-lines"; 
+            mapColour: {r: number; g: number; b: number}; 
+            positiveMapColour: {r: number; g: number; b: number}; 
+            negativeMapColour: {r: number; g: number; b: number}
+        };
+        fetchColourAndRedraw(): Promise<void> ;
+        fetchDiffMapColourAndRedraw(type: 'positiveDiffColour' | 'negativeDiffColour'): Promise<void> ;
         fetchMapRmsd(): Promise<number>;
         fetchSuggestedLevel(): Promise<number>;
         fetchMapCentre(): Promise<[number, number, number]>;
         replaceMapWithMtzFile(fileUrl: RequestInfo | URL, selectedColumns: _moorhen.selectedMtzColumns): Promise<void>;
         associateToReflectionData (selectedColumns: _moorhen.selectedMtzColumns, reflectionData: Uint8Array | ArrayBuffer): Promise<void>;
         delete(): Promise<void> 
-        doCootContour(x: number, y: number, z: number, radius: number, contourLevel: number): Promise<void>;
+        doCootContour(x: number, y: number, z: number, radius: number, contourLevel: number, style: "lines" | "lit-lines" | "solid"): Promise<void>;
         fetchReflectionData(): Promise<_moorhen.WorkerResponse<Uint8Array>>;
         getMap(): Promise<_moorhen.WorkerResponse>;
         loadToCootFromMtzURL(url: RequestInfo | URL, name: string, selectedColumns: _moorhen.selectedMtzColumns, options?: RequestInit): Promise<_moorhen.Map>;
@@ -185,14 +199,9 @@ declare module 'moorhen' {
         molNo: number;
         commandCentre: React.RefObject<_moorhen.CommandCentre>;
         glRef: React.RefObject<webGL.MGWebGL>;
-        contourLevel: number;
-        mapRadius: number;
-        mapColour: [number, number, number, number];
         webMGContour: boolean;
-        isVisible: boolean;
+        showOnLoad: boolean;
         displayObjects: any;
-        litLines: boolean;
-        solid: boolean;
         isDifference: boolean;
         hasReflectionData: boolean;
         selectedColumns: _moorhen.selectedMtzColumns;
@@ -201,18 +210,12 @@ declare module 'moorhen' {
         otherMapForColouring: {molNo: number, min: number, max: number};
         mapRmsd: number;
         suggestedMapWeight: number;
-        rgba: {
-            mapColour: {r: number, g: number, b: number};
-            positiveDiffColour: {r: number, g: number, b: number};
-            negativeDiffColour: {r: number, g: number, b: number};
-            a: number;
-        }
+        defaultMapColour: {r: number, g: number, b: number};
+        defaultPositiveMapColour: {r: number, g: number, b: number};
+        defaultNegativeMapColour: {r: number, g: number, b: number};
     }
     module.exports.MoorhenMap = MoorhenMap
 
-    function getMoleculeBfactors(gemmiStructure: gemmi.Structure): { cid: string, bFactor: number, chainId: string, resNum: number, modelName: string }[];
-    module.exports = getMoleculeBfactors;
-
     function loadSessionData(
         sessionDataString: string,
         monomerLibraryPath: string,

package/types/mgWebGL.d.ts

@@ -18,7 +18,11 @@ export namespace webGL {
         createIndexBuffer(tri: number[]) : void;
         createSizeBuffer(tri: number[]) : void;
         addSupplementaryInfo(info: any, name: string) : void;
-
+        calculateOriginDelta(newOrigin: [number, number, number], oldOrigin: [number, number, number], nFrames: number): [number, number, number];
+        setOriginAndZoomAnimated(newOrigin: [number, number, number], newZoom: number): void;
+        drawOriginAndZoomFrame(oldOrigin: [number, number, number], oldZoom: number, deltaOrigin: [number, number, number], deltaZoom: number, iframe: number): void;
+        setZoomAnimated(newZoom: number): void;
+        drawZoomFrame(oldZoom: number, newZoom: number, iframe: number): void;
         createInstanceSizesBuffer(tri: number[]) : void;
         createVertexBuffer(tri: number[]) : void;
         createRealNormalBuffer(tri: number[]) : void;
@@ -38,8 +42,8 @@ export namespace webGL {
         drawSceneIfDirty() : void;
         drawFPSMeter() : void;
         linesToThickLines(axesVertices: number[], axesColours: number[], size: number) : any;
-        linesToThickLinesWithIndicesAndNormals(axesVertices: number[], axesNormals: number[], axesColours: number[], axesIndices: number[], size: number) : any;
-        linesToThickLinesWithIndices(axesVertices: number[], axesColours: number[], axesIndices: number[], size: number, axesNormals_old? : number) : any;
+        linesToThickLinesWithIndicesAndNormals(axesVertices: number[], axesNormals: number[], axesColours: number[], axesIndices: number[], size: number, doColour : boolean|null) : any;
+        linesToThickLinesWithIndices(axesVertices: number[], axesColours: number[], axesIndices: number[], size: number, axesNormals_old? : number[], doColour : boolean|null) : any;
         doWheel(event: Event) : void;
         doHover(event: Event, self: any) : void;
         handleKeyUp(event: Event, self: any) : void;
@@ -115,7 +119,7 @@ export namespace webGL {
         appendOtherData(jsondata: any, skipRebuild?: boolean, name?: string) : any;
         setZoom(z: number, drawScene?: boolean);
         setOriginOrientationAndZoomAnimated(o: number[],q: quat4,z: number) : void;
-        setOriginAnimated(o: number[], doDrawScene=true) : void;
+        setOriginAnimated(o: number[]) : void;
         initTextureFramebuffer() : void;
         clearMeasureCylinderBuffers() : void;
         getFrontAndBackPos(event: KeyboardEvent) : [number[], number[], number, number];
@@ -234,7 +238,7 @@ export namespace webGL {
         cancelMouseTrack: boolean;
         circleTex: WebGLTexture;
         clipChangedEvent: Event;
-        context: CanvasRenderingContext2D;
+        context2d: CanvasRenderingContext2D;
         diskBuffer: DisplayBuffer;
         diskVertices: number[];
         doShadow: boolean;
@@ -284,6 +288,7 @@ export namespace webGL {
         mouseTrackPositionBuffer: WebGLBuffer;
         moveFactor: number;
         mspfArray: number[];
+        pointsArray: number[];
         mvInvMatrix: Float32Array;
         mvMatrix: Float32Array;
         nAnimationFrames: number;
@@ -393,6 +398,8 @@ export namespace webGL {
         ext: any;
         newTextLabels: any;
         drawingGBuffers: boolean;
+        initializeShaders() : void;
+        axesTexture: any;
 
     }
 }