molstar 4.2.0 → 4.3.0

package/lib/extensions/sb-ncbr/tunnels/behavior.js

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginBehavior } from '../../../mol-plugin/behavior';
+import { DownloadTunnels } from './actions';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { PresetStructureRepresentations, StructureRepresentationPresetProvider } from '../../../mol-plugin-state/builder/structure/representation-preset';
+import { Model } from '../../../mol-model/structure';
+import { StateObjectRef } from '../../../mol-state';
+import { getTunnelsConfig, TunnelsDataParams } from './props';
+import { StateTransforms } from '../../../mol-plugin-state/transforms';
+import { TunnelShapeProvider, TunnelFromRawData } from './representation';
+import { ColorGenerator } from '../../meshes/mesh-utils';
+export const SbNcbrTunnels = PluginBehavior.create({
+    name: 'sb-ncbr-tunnels',
+    category: 'misc',
+    display: {
+        name: 'SB NCBR Tunnels',
+    },
+    ctor: class extends PluginBehavior.Handler {
+        register() {
+            this.ctx.state.data.actions.add(DownloadTunnels);
+            this.ctx.builders.structure.representation.registerPreset(TunnelsPreset);
+        }
+        unregister() {
+            this.ctx.state.data.actions.remove(DownloadTunnels);
+            this.ctx.builders.structure.representation.unregisterPreset(TunnelsPreset);
+        }
+    },
+    params: () => ({
+        autoAttach: PD.Boolean(true),
+    })
+});
+export function isApplicable(structure) {
+    return (!!structure && structure.models.length === 1 &&
+        Model.hasPdbId(structure.models[0]));
+}
+export const TunnelsPreset = StructureRepresentationPresetProvider({
+    id: 'sb-ncbr-preset-structure-tunnels',
+    display: {
+        name: 'Tunnels', group: 'Annotation',
+        description: 'Shows Tunnels from ChannelsDB contained in the structure.'
+    },
+    isApplicable(a) {
+        return isApplicable(a.data);
+    },
+    params: (a, plugin) => {
+        return {
+            ...StructureRepresentationPresetProvider.CommonParams,
+            ...getConfiguredDefaultParams(plugin)
+        };
+    },
+    async apply(ref, params, plugin) {
+        var _a, _b;
+        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
+        const structure = (_a = structureCell === null || structureCell === void 0 ? void 0 : structureCell.obj) === null || _a === void 0 ? void 0 : _a.data;
+        if (!structureCell || !structure)
+            return {};
+        const update = plugin.build();
+        const webgl = (_b = plugin.canvas3dContext) === null || _b === void 0 ? void 0 : _b.webgl;
+        const response = await (await fetch(`${params.serverUrl}/channels/${params.serverType}/${structure.model.entryId.toLowerCase()}`)).json();
+        const tunnels = [];
+        Object.entries(response.Channels).forEach(([key, values]) => {
+            if (values.length > 0) {
+                values.forEach((item) => {
+                    tunnels.push({ data: item.Profile, props: { id: item.Id, type: item.Type } });
+                });
+            }
+        });
+        await tunnels.forEach(async (tunnel) => {
+            await update
+                .toRoot()
+                .apply(TunnelFromRawData, { data: tunnel })
+                .apply(TunnelShapeProvider, {
+                webgl,
+                colorTheme: ColorGenerator.next().value,
+            })
+                .apply(StateTransforms.Representation.ShapeRepresentation3D);
+            await update.commit();
+        });
+        const preset = await PresetStructureRepresentations.auto.apply(ref, { ...params }, plugin);
+        return { components: preset.components, representations: { ...preset.representations, } };
+    }
+});
+function getConfiguredDefaultParams(plugin) {
+    const config = getTunnelsConfig(plugin);
+    const params = PD.clone(TunnelsDataParams);
+    PD.setDefaultValues(params, { serverType: config.DefaultServerType, serverUrl: config.DefaultServerUrl });
+    return params;
+}

package/lib/extensions/sb-ncbr/tunnels/data-model.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { WebGLContext } from '../../../mol-gl/webgl/context';
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export interface Profile {
+    Charge: number;
+    Radius: number;
+    FreeRadius: number;
+    T: number;
+    Distance: number;
+    X: number;
+    Y: number;
+    Z: number;
+}
+export interface Layerweightedproperties {
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayerGeometry {
+    MinRadius: number;
+    MinFreeRadius: number;
+    StartDistance: number;
+    EndDistance: number;
+    LocalMinimum: boolean;
+    Bottleneck: boolean;
+    bottleneck: boolean;
+}
+export interface Properties {
+    Charge: number;
+    NumPositives: number;
+    NumNegatives: number;
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayersInfo {
+    LayerGeometry: LayerGeometry;
+    Residues: string[];
+    FlowIndices: string[];
+    Properties: Properties;
+}
+export interface Layers {
+    ResidueFlow: string[];
+    HetResidues: any[];
+    LayerWeightedProperties: Layerweightedproperties;
+    LayersInfo: LayersInfo[];
+}
+export interface TunnelDB {
+    Type: string;
+    Id: string;
+    Cavity: string;
+    Auto: boolean;
+    Properties: Properties;
+    Profile: Profile[];
+    Layers: Layers;
+}
+export interface ChannelsDBdata {
+    'CSATunnels_MOLE': TunnelDB[];
+    'CSATunnels_Caver': TunnelDB[];
+    'ReviewedChannels_MOLE': TunnelDB[];
+    'ReviewedChannels_Caver': TunnelDB[];
+    'CofactorTunnels_MOLE': TunnelDB[];
+    'CofactorTunnels_Caver': TunnelDB[];
+    'TransmembranePores_MOLE': TunnelDB[];
+    'TransmembranePores_Caver': TunnelDB[];
+    'ProcognateTunnels_MOLE': TunnelDB[];
+    'ProcognateTunnels_Caver': TunnelDB[];
+    'AlphaFillTunnels_MOLE': TunnelDB[];
+    'AlphaFillTunnels_Caver': TunnelDB[];
+}
+export interface ChannelsCache {
+    Channels: ChannelsDBdata;
+}
+export interface Tunnel {
+    data: Profile[];
+    props: {
+        highlight_label?: string;
+        type?: string;
+        id?: string;
+        label?: string;
+        description?: string;
+    };
+}
+export declare const TunnelShapeParams: {
+    webgl: PD.Value<WebGLContext | null>;
+    colorTheme: PD.Color;
+    visual: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "mesh">>;
+    samplingRate: PD.Numeric;
+    showRadii: PD.BooleanParam;
+};
+declare const TunnelStateObject_base: {
+    new (data: {
+        tunnel: Tunnel;
+    }, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: {
+            tunnel: Tunnel;
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../../mol-state").StateObject<{
+        tunnel: Tunnel;
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelStateObject extends TunnelStateObject_base {
+}
+declare const TunnelsStateObject_base: {
+    new (data: {
+        tunnels: Tunnel[];
+    }, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: {
+            tunnels: Tunnel[];
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../../mol-state").StateObject<{
+        tunnels: Tunnel[];
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelsStateObject extends TunnelsStateObject_base {
+}
+export {};

package/lib/extensions/sb-ncbr/tunnels/data-model.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { Color } from '../../../mol-util/color';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+;
+export const TunnelShapeParams = {
+    webgl: PD.Value(null),
+    colorTheme: PD.Color(Color(0xff0000)),
+    visual: PD.MappedStatic('mesh', {
+        mesh: PD.Group({ resolution: PD.Numeric(2) }),
+        spheres: PD.Group({ resolution: PD.Numeric(2) })
+    }),
+    samplingRate: PD.Numeric(1, { min: 0.05, max: 1, step: 0.05 }),
+    showRadii: PD.Boolean(false),
+};
+export class TunnelStateObject extends PluginStateObject.Create({ name: 'Tunnel Entry', typeClass: 'Data' }) {
+}
+export class TunnelsStateObject extends PluginStateObject.Create({ name: 'Tunnels', typeClass: 'Data' }) {
+}

package/lib/extensions/sb-ncbr/tunnels/examples.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginContext } from '../../../mol-plugin/context';
+export declare const DB_URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/";
+export declare const SUB_DB = "pdb";
+export declare const CHANNEL = "1ymg";
+export declare const URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/pdb/1ymg";
+export declare function runVisualizeTunnels(plugin: PluginContext, url?: string): Promise<void>;
+export declare function runVisualizeTunnel(plugin: PluginContext): Promise<void>;

package/lib/extensions/sb-ncbr/tunnels/examples.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { StateTransforms } from '../../../mol-plugin-state/transforms';
+import { TunnelsFromRawData, SelectTunnel, TunnelShapeProvider, TunnelFromRawData } from './representation';
+export const DB_URL = 'https://channelsdb2.biodata.ceitec.cz/api/channels/';
+export const SUB_DB = 'pdb';
+export const CHANNEL = '1ymg';
+export const URL = `${DB_URL}${SUB_DB}/${CHANNEL}`;
+export async function runVisualizeTunnels(plugin, url = URL) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(url)).json();
+    const tunnels = [];
+    Object.entries(response.Channels).forEach(([key, values]) => {
+        if (values.length > 0) {
+            values.forEach((item) => {
+                tunnels.push({ data: item.Profile, props: { id: item.Id, type: item.Type } });
+            });
+        }
+    });
+    update
+        .toRoot()
+        .apply(TunnelsFromRawData, { data: tunnels })
+        .apply(SelectTunnel)
+        .apply(TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}
+export async function runVisualizeTunnel(plugin) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(URL)).json();
+    const tunnel = response.Channels.TransmembranePores_MOLE[0];
+    update
+        .toRoot()
+        .apply(TunnelFromRawData, { data: { data: tunnel.Profile, props: { id: tunnel.Id, type: tunnel.Type } } })
+        .apply(TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}

package/lib/extensions/sb-ncbr/tunnels/props.d.ts

@@ -0,0 +1,19 @@
+import { PluginConfigItem } from '../../../mol-plugin/config';
+import { PluginContext } from '../../../mol-plugin/context';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare namespace TunnelsData {
+    const DefaultServerUrl = "https://channelsdb2.biodata.ceitec.cz/api";
+    const DefaultServerType = "pdb";
+}
+export declare const TunnelsDataParams: {
+    serverType: PD.Select<"pdb">;
+    serverUrl: PD.Text<string>;
+};
+export type TunnelsDataParams = typeof TunnelsDataParams;
+export declare const TunnelsServerConfig: {
+    DefaultServerUrl: PluginConfigItem<string>;
+    DefaultServerType: PluginConfigItem<"pdb">;
+};
+export declare function getTunnelsConfig(plugin: PluginContext): {
+    [key in keyof typeof TunnelsServerConfig]: NonNullable<typeof TunnelsServerConfig[key]['defaultValue']>;
+};

package/lib/extensions/sb-ncbr/tunnels/props.js

@@ -0,0 +1,22 @@
+import { PluginConfigItem } from '../../../mol-plugin/config';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export var TunnelsData;
+(function (TunnelsData) {
+    TunnelsData.DefaultServerUrl = 'https://channelsdb2.biodata.ceitec.cz/api';
+    TunnelsData.DefaultServerType = 'pdb';
+})(TunnelsData || (TunnelsData = {}));
+export const TunnelsDataParams = {
+    serverType: PD.Select('pdb', [['pdb', 'pdb']]),
+    serverUrl: PD.Text(TunnelsData.DefaultServerUrl)
+};
+export const TunnelsServerConfig = {
+    DefaultServerUrl: new PluginConfigItem('channelsdb-server', 'https://channelsdb2.biodata.ceitec.cz/api'),
+    DefaultServerType: new PluginConfigItem('serverType', 'pdb')
+};
+export function getTunnelsConfig(plugin) {
+    var _a, _b, _c, _d;
+    return {
+        DefaultServerUrl: (_b = (_a = plugin.config.get(TunnelsServerConfig.DefaultServerUrl)) !== null && _a !== void 0 ? _a : TunnelsServerConfig.DefaultServerUrl.defaultValue) !== null && _b !== void 0 ? _b : TunnelsData.DefaultServerUrl,
+        DefaultServerType: (_d = (_c = plugin.config.get(TunnelsServerConfig.DefaultServerType)) !== null && _c !== void 0 ? _c : TunnelsServerConfig.DefaultServerType.defaultValue) !== null && _d !== void 0 ? _d : TunnelsData.DefaultServerType,
+    };
+}

package/lib/extensions/sb-ncbr/tunnels/representation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { StateTransformer } from '../../../mol-state';
+import { TunnelStateObject, Tunnel, TunnelsStateObject } from './data-model';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare const TunnelsFromRawData: StateTransformer<PluginStateObject.Root, TunnelsStateObject, PD.Normalize<{
+    data: Tunnel[];
+}>>;
+export declare const SelectTunnel: StateTransformer<TunnelsStateObject, TunnelStateObject, PD.Normalize<{
+    index: number;
+}>>;
+export declare const TunnelFromRawData: StateTransformer<PluginStateObject.Root, TunnelStateObject, PD.Normalize<{
+    data: Tunnel;
+}>>;
+export declare const TunnelShapeProvider: StateTransformer<TunnelStateObject, PluginStateObject.Shape.Provider, PD.Normalize<{
+    webgl: import("../../../mol-gl/webgl/context").WebGLContext | null;
+    colorTheme: import("../../../mol-util/color").Color;
+    visual: PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "mesh">;
+    samplingRate: number;
+    showRadii: boolean;
+}>>;

package/lib/extensions/sb-ncbr/tunnels/representation.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { StateTransformer } from '../../../mol-state';
+import { TunnelStateObject, TunnelShapeParams, TunnelsStateObject } from './data-model';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
+import { Task } from '../../../mol-task';
+import { createTunnelShape, createSpheresShape } from './algorithm';
+const Transform = StateTransformer.builderFactory('sb-ncbr-tunnels');
+export const TunnelsFromRawData = Transform({
+    name: 'sb-ncbr-tunnels-from-data',
+    display: { name: 'Tunnels' },
+    from: PluginStateObject.Root,
+    to: TunnelsStateObject,
+    params: {
+        data: PD.Value([]),
+    },
+})({
+    apply({ params }) {
+        return new TunnelsStateObject({ tunnels: params.data });
+    },
+});
+export const SelectTunnel = Transform({
+    name: 'sb-ncbr-tunnel-from-tunnels',
+    display: { name: 'Tunnel Selection' },
+    from: TunnelsStateObject,
+    to: TunnelStateObject,
+    params: a => {
+        return {
+            index: PD.Numeric(0, { min: 0, max: a.data.tunnels.length - 1, step: 1 })
+        };
+    }
+})({
+    apply({ a, params }) {
+        return new TunnelStateObject({ tunnel: a.data.tunnels[params.index] });
+    }
+});
+export const TunnelFromRawData = Transform({
+    name: 'sb-ncbr-tunnel-from-data',
+    display: { name: 'Tunnel Entry' },
+    from: PluginStateObject.Root,
+    to: TunnelStateObject,
+    params: {
+        data: PD.Value(undefined, { isHidden: true })
+    },
+})({
+    apply({ params }) {
+        return new TunnelStateObject({ tunnel: params.data });
+    },
+});
+export const TunnelShapeProvider = Transform({
+    name: 'sb-ncbr-tunnel-shape-provider',
+    display: { name: 'Tunnel' },
+    from: TunnelStateObject,
+    to: PluginStateObject.Shape.Provider,
+    params: a => { return TunnelShapeParams; },
+})({
+    apply({ a, params }) {
+        return Task.create('Tunnel Shape Representation', async (ctx) => {
+            var _a, _b;
+            return new PluginStateObject.Shape.Provider({
+                label: 'Surface',
+                data: { params, data: a.data },
+                params: Mesh.Params,
+                geometryUtils: Mesh.Utils,
+                getShape: (_, data, __, mesh) => {
+                    if (data.params.visual.name === 'mesh' && !data.params.showRadii) {
+                        return createTunnelShape({
+                            tunnel: data.data.tunnel,
+                            color: data.params.colorTheme,
+                            resolution: data.params.visual.params.resolution,
+                            sampleRate: data.params.samplingRate,
+                            webgl: data.params.webgl, prev: mesh
+                        });
+                    }
+                    return createSpheresShape({
+                        tunnel: data.data.tunnel,
+                        color: data.params.colorTheme,
+                        resolution: data.params.visual.params.resolution,
+                        sampleRate: data.params.samplingRate,
+                        showRadii: data.params.showRadii, prev: mesh
+                    });
+                }
+            }, {
+                label: (_a = a.data.tunnel.props.label) !== null && _a !== void 0 ? _a : 'Tunnel',
+                description: ((_b = a.data.tunnel.props.description) !== null && _b !== void 0 ? _b : (a.data.tunnel.props.type && a.data.tunnel.props.id))
+                    ? `${a.data.tunnel.props.type} ${a.data.tunnel.props.id}`
+                    : '',
+            });
+        });
+    },
+});

package/lib/mol-canvas3d/canvas3d.d.ts

@@ -87,6 +87,14 @@ export declare const Canvas3DParams: {
             color: any;
             includeTransparent: any;
         }>, "on">;
+        dof: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            blurSize: any;
+            blurSpread: any;
+            inFocus: any;
+            PPM: any;
+            center: any;
+            mode: any;
+        }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
             maxSearchSteps: any;
@@ -302,6 +310,14 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             color: any;
             includeTransparent: any;
         }>, "on">;
+        dof: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            blurSize: any;
+            blurSpread: any;
+            inFocus: any;
+            PPM: any;
+            center: any;
+            mode: any;
+        }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
             maxSearchSteps: any;
@@ -519,6 +535,7 @@ interface Canvas3D {
     tick(t: now.Timestamp, options?: {
         isSynchronous?: boolean;
         manualDraw?: boolean;
+        updateControls?: boolean;
     }): void;
     update(repr?: Representation.Any, keepBoundingSphere?: boolean): void;
     clear(): void;

package/lib/mol-canvas3d/canvas3d.js

@@ -391,6 +391,10 @@ var Canvas3D;
         function tick(t, options) {
             currentTime = t;
             commit(options === null || options === void 0 ? void 0 : options.isSynchronous);
+            // update the controler before the camera transition
+            if (options === null || options === void 0 ? void 0 : options.updateControls) {
+                controls.update(currentTime);
+            }
             camera.transition.tick(currentTime);
             hiZ.tick();
             if (options === null || options === void 0 ? void 0 : options.manualDraw) {

package/lib/mol-canvas3d/passes/dof.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Ludovic Autin <autin@scripps.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { WebGLContext } from '../../mol-gl/webgl/context';
+import { Texture } from '../../mol-gl/webgl/texture';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { Viewport } from '../camera/util';
+import { RenderTarget } from '../../mol-gl/webgl/render-target';
+import { ICamera } from '../../mol-canvas3d/camera';
+import { Sphere3D } from '../../mol-math/geometry';
+import { PostprocessingProps } from './postprocessing';
+export declare const DofParams: {
+    blurSize: PD.Numeric;
+    blurSpread: PD.Numeric;
+    inFocus: PD.Numeric;
+    PPM: PD.Numeric;
+    center: PD.Select<string>;
+    mode: PD.Select<string>;
+};
+export type DofProps = PD.Values<typeof DofParams>;
+export declare class DofPass {
+    private webgl;
+    static isEnabled(props: PostprocessingProps): boolean;
+    readonly target: RenderTarget;
+    private readonly renderable;
+    constructor(webgl: WebGLContext, width: number, height: number);
+    private updateState;
+    setSize(width: number, height: number): void;
+    update(camera: ICamera, input: Texture, depthOpaque: Texture, depthTransparent: Texture, props: DofProps, sphere: Sphere3D): void;
+    render(viewport: Viewport, target: undefined | RenderTarget): void;
+}