moorhen 0.6.8 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moorhen",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "private": false,
   "main": "moorhen.js",
   "types": "./types/main.d.ts",

package/types/libcoot.d.ts

@@ -12,6 +12,9 @@ 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;
@@ -20,12 +23,12 @@ export namespace libcootApi {
             cid: string;
         }>;
         guess_coord_data_format(coordDataString: string): number;
-        get_structure_bfactors(gemmiStructure: gemmi.Structure): emscriptem.vector<{ cid: string; bFactor: 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;
@@ -234,11 +237,11 @@ export namespace libcootApi {
     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 {
         cell: CellTranslation;
@@ -349,7 +352,7 @@ 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];
@@ -420,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: {
@@ -429,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};
@@ -437,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>;
@@ -83,7 +84,7 @@ declare module 'moorhen' {
         clearExtraRestraints(): Promise<_moorhen.WorkerResponse>;
         refineResiduesUsingAtomCid(cid: string, mode: string, ncyc?: number, redraw?: boolean): Promise<void>;
         getNcsRelatedChains(): Promise<string[][]>;
-        getResidueBFactors(): { cid: string, bFactor: number }[];
+        getResidueBFactors(): { cid: string; bFactor: number; normalised_bFactor: number }[];
         redo(): Promise<void>;
         undo(): Promise<void>;
         show(style: string, cid?: string): void;
@@ -105,7 +106,7 @@ 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>;
@@ -116,7 +117,6 @@ declare module 'moorhen' {
         commandCentre: React.RefObject<_moorhen.CommandCentre>;
         glRef: React.RefObject<webGL.MGWebGL>;
         atomsDirty: boolean;
-        isVisible: boolean;
         name: string;
         molNo: number;
         gemmiStructure: gemmi.Structure;
@@ -159,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>;
@@ -190,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;
@@ -206,12 +210,9 @@ 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
 

package/types/mgWebGL.d.ts

@@ -42,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;
@@ -238,7 +238,7 @@ export namespace webGL {
         cancelMouseTrack: boolean;
         circleTex: WebGLTexture;
         clipChangedEvent: Event;
-        context: CanvasRenderingContext2D;
+        context2d: CanvasRenderingContext2D;
         diskBuffer: DisplayBuffer;
         diskVertices: number[];
         doShadow: boolean;
@@ -288,6 +288,7 @@ export namespace webGL {
         mouseTrackPositionBuffer: WebGLBuffer;
         moveFactor: number;
         mspfArray: number[];
+        pointsArray: number[];
         mvInvMatrix: Float32Array;
         mvMatrix: Float32Array;
         nAnimationFrames: number;
@@ -397,6 +398,8 @@ export namespace webGL {
         ext: any;
         newTextLabels: any;
         drawingGBuffers: boolean;
+        initializeShaders() : void;
+        axesTexture: any;
 
     }
 }

package/types/moorhen.d.ts

@@ -28,6 +28,7 @@ export namespace moorhen {
         modelName: string;
         cid: string;
         svg?: string;
+        chem_comp_info?: {first: string; second: string}[];
     }
     
     type Sequence = {
@@ -91,8 +92,10 @@ export namespace moorhen {
     type coorFormats = 'pdb' | 'mmcif';
     
     interface Molecule {
+        getNonSelectedCids(cid: string): string[];
+        parseCidIntoSelection(selectedCid: string): Promise<ResidueSelection>;
         downloadAtoms(format?: 'mmcif' | 'pdb'): Promise<void>;
-        getResidueBFactors(): { cid: string, bFactor: number }[];
+        getResidueBFactors(): { cid: string; bFactor: number; normalised_bFactor: number }[];
         getNcsRelatedChains(): Promise<string[][]>;
         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>;
@@ -147,7 +150,7 @@ export namespace 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>;
@@ -157,7 +160,6 @@ export namespace moorhen {
         commandCentre: React.RefObject<CommandCentre>;
         glRef: React.RefObject<webGL.MGWebGL>;
         atomsDirty: boolean;
-        isVisible: boolean;
         name: string;
         molNo: number;
         gemmiStructure: gemmi.Structure;
@@ -240,6 +242,7 @@ export namespace moorhen {
         second: null | string;
         cid: null | string | string[];
         isMultiCid: boolean;
+        label: string;
     }
     
     type HoveredAtom = {
@@ -363,21 +366,30 @@ export namespace moorhen {
         getHistogram(nBins?: number, zoomFactor?: number): Promise<libcootApi.HistogramInfoJS>;
         setMapWeight(weight?: number): Promise<WorkerResponse>;
         estimateMapWeight(): Promise<void>;
-        setAlpha(alpha: number, redraw?: boolean): Promise<void>;
+        fetchMapAlphaAndRedraw(): Promise<void>;
         centreOnMap(): Promise<void>;
         getSuggestedSettings(): Promise<void>;
-        duplicate(): Promise<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<Map>;
+        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}
+        };
+        hideMapContour(): void;
+        drawMapContour(): Promise<void>;
+        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: selectedMtzColumns): Promise<void>;
         associateToReflectionData (selectedColumns: 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<WorkerResponse<Uint8Array>>;
         getMap(): Promise<WorkerResponse>;
         loadToCootFromMtzURL(url: RequestInfo | URL, name: string, selectedColumns: selectedMtzColumns, options?: RequestInit): Promise<Map>;
@@ -394,14 +406,9 @@ export namespace moorhen {
         molNo: number;
         commandCentre: React.RefObject<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: selectedMtzColumns;
@@ -410,12 +417,9 @@ export namespace 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};
     }
     
     interface backupKey {
@@ -446,11 +450,16 @@ export namespace moorhen {
         uniqueId: string;
         mapData: Uint8Array;
         reflectionData: Uint8Array;
-        isVisible: boolean;
+        showOnLoad: boolean;
         contourLevel: number;
         radius: number;
-        colour: [number, number, number, number];
-        litLines: boolean;
+        rgba: {
+            mapColour: {r: number, g: number, b: number};
+            positiveDiffColour: {r: number, g: number, b: number};
+            negativeDiffColour: {r: number, g: number, b: number};
+            a: number;
+        };
+        style: "solid" | "lit-lines" | "lines";
         isDifference: boolean;
         selectedColumns: selectedMtzColumns;
         hasReflectionData: boolean;
@@ -731,12 +740,6 @@ export namespace moorhen {
     interface State {
         molecules: Molecule[];
         maps: Map[];
-        mapSettings: {
-            defaultMapSamplingRate: number;
-            defaultMapLitLines: boolean;
-            mapLineWidth: number;
-            defaultMapSurface: boolean;
-        };
         mouseSettings: {
             contourWheelSensitivityFactor: number;
             zoomWheelSensitivityFactor: number;
@@ -807,6 +810,7 @@ export namespace moorhen {
             isDraggingAtoms: boolean;
             isRotatingAtoms: boolean;
             newCootCommandAlert: boolean;
+            showResidueSelection: boolean;
         };
         hoveringStates: {
             enableAtomHovering: boolean;
@@ -817,11 +821,37 @@ export namespace moorhen {
             showModelsModal: boolean;
             showMapsModal: boolean;
             showCreateAcedrgLinkModal: boolean;
-            showValidationModal: boolean;
             showQuerySequenceModal: boolean;
             showScriptingModal: boolean;
             showControlsModal: boolean;
             showFitLigandModal: boolean;
+            showRamaPlotModal: boolean;
+            showDiffMapPeaksModal: boolean;
+            showValidationPlotModal: boolean;
+            showLigandValidationModal: boolean;
+            showPepFlipsValidationModal: boolean;
+            showFillPartialResValidationModal: boolean;
+            showUnmodelledBlobsModal: boolean;
+            showMmrrccModal: boolean;
+            showWaterValidationModal: boolean;
+            focusHierarchy: string[];
+        };
+        mapContourSettings: {
+            visibleMaps: number[];
+            contourLevels: { molNo: number; contourLevel: number }[];
+            mapRadii: { molNo: number; radius: number }[];
+            mapAlpha: { molNo: number; alpha: number }[];
+            mapStyles: { molNo: number; style: "solid" | "lit-lines" | "lines" }[];
+            defaultMapSamplingRate: number;
+            defaultMapLitLines: boolean;
+            mapLineWidth: number;
+            defaultMapSurface: boolean;
+            mapColours: { molNo: number; rgb: {r: number, g: number, b: number} }[];
+            negativeMapColours: { molNo: number; rgb: {r: number, g: number, b: number} }[];
+            positiveMapColours: { molNo: number; rgb: {r: number, g: number, b: number} }[];
+        };
+        moleculeRepresentations: {
+            visibleMolecules: number[];
         };
     }