@webviz/subsurface-viewer 0.0.1-alpha.1

package/src/layers/map/privateMapLayer.ts

@@ -0,0 +1,317 @@
+import {
+    COORDINATE_SYSTEM,
+    Layer,
+    picking,
+    project,
+    phongLighting,
+    PickingInfo,
+    UpdateParameters,
+    Color,
+} from "@deck.gl/core/typed";
+import {
+    createPropertyData,
+    LayerPickInfo,
+    PropertyDataType,
+} from "../utils/layerTools";
+import { Model, Geometry } from "@luma.gl/engine";
+import { DeckGLLayerContext } from "../../components/Map";
+import { ExtendedLayerProps, colorMapFunctionType } from "../utils/layerTools";
+import vsShader from "./vertex.glsl";
+import fsShader from "./fragment.fs.glsl";
+import vsLineShader from "./vertex_lines.glsl";
+import fsLineShader from "./fragment_lines.glsl";
+
+import { colorTablesArray, rgbValues } from "@emerson-eps/color-tables/";
+import { createDefaultContinuousColorScale } from "@emerson-eps/color-tables/dist/component/Utils/legendCommonFunction";
+import { Texture2D } from "@luma.gl/webgl";
+import GL from "@luma.gl/constants";
+
+const DEFAULT_TEXTURE_PARAMETERS = {
+    [GL.TEXTURE_MIN_FILTER]: GL.LINEAR_MIPMAP_LINEAR,
+    [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
+    [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+    [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE,
+};
+
+export type MeshType = {
+    drawMode?: number;
+    attributes: {
+        positions: { value: Float32Array; size: number };
+        TEXCOORD_0?: { value: Float32Array; size: number };
+        normals: { value: Float32Array; size: number };
+        properties: { value: Float32Array; size: number };
+        vertex_indexs: { value: Int32Array; size: number };
+    };
+    vertexCount: number;
+    indices: { value: Uint32Array; size: number };
+};
+
+export type MeshTypeLines = {
+    drawMode: number;
+    attributes: {
+        positions: { value: Float32Array; size: number };
+    };
+    vertexCount: number;
+};
+
+export type Material =
+    | {
+          ambient: number;
+          diffuse: number;
+          shininess: number;
+          specularColor: [number, number, number];
+      }
+    | boolean;
+
+function getImageData(
+    colorMapName: string,
+    colorTables: colorTablesArray,
+    colorMapFunction: colorMapFunctionType | undefined
+) {
+    type funcType = (x: number) => Color;
+
+    const isColorMapFunctionDefined = typeof colorMapFunction !== "undefined";
+    const isColorMapNameDefined = !!colorMapName;
+
+    const defaultColorMap = createDefaultContinuousColorScale;
+    let colorMap = defaultColorMap() as unknown as funcType;
+
+    if (isColorMapFunctionDefined) {
+        colorMap =
+            typeof colorMapFunction === "function"
+                ? (colorMapFunction as funcType)
+                : ((() => colorMapFunction) as unknown as funcType);
+    } else if (isColorMapNameDefined) {
+        colorMap = (value: number) =>
+            rgbValues(value, colorMapName, colorTables);
+    }
+
+    const data = new Uint8Array(256 * 3);
+
+    for (let i = 0; i < 256; i++) {
+        const value = i / 255.0;
+        const color = colorMap ? colorMap(value) : [0, 0, 0];
+        if (color) {
+            data[3 * i + 0] = color[0];
+            data[3 * i + 1] = color[1];
+            data[3 * i + 2] = color[2];
+        }
+    }
+
+    return data ? data : [0, 0, 0];
+}
+
+export interface privateMapLayerProps<D> extends ExtendedLayerProps<D> {
+    mesh: MeshType;
+    meshLines: MeshTypeLines;
+    contours: [number, number];
+    gridLines: boolean;
+    isContoursDepth: boolean;
+    colorMapName: string;
+    colorMapRange: [number, number];
+    colorMapClampColor: Color | undefined | boolean;
+    colorMapFunction?: colorMapFunctionType;
+    propertyValueRange: [number, number];
+    smoothShading: boolean;
+    depthTest: boolean;
+}
+
+const defaultProps = {
+    data: ["dummy"],
+    contours: [-1, -1],
+    isContoursDepth: true,
+    gridLines: false,
+    colorMapName: "",
+    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+    propertyValueRange: [0.0, 1.0],
+    meshValueRange: [0.0, 1.0],
+    depthTest: true,
+};
+
+// This is a private layer used only by the composite Map3DLayer
+export default class privateMapLayer extends Layer<
+    privateMapLayerProps<unknown>
+> {
+    initializeState(context: DeckGLLayerContext): void {
+        const { gl } = context;
+        const [model_mesh, mesh_lines_model] = this._getModels(gl);
+        this.setState({ models: [model_mesh, mesh_lines_model] });
+    }
+
+    shouldUpdateState({
+        props,
+        oldProps,
+        context,
+        changeFlags,
+    }: UpdateParameters<this>): boolean {
+        return (
+            super.shouldUpdateState({
+                props,
+                oldProps,
+                context,
+                changeFlags,
+            }) || changeFlags.propsOrDataChanged
+        );
+    }
+
+    updateState({ context }: UpdateParameters<this>): void {
+        this.initializeState(context as DeckGLLayerContext);
+    }
+
+    //eslint-disable-next-line
+    _getModels(gl: any) {
+        // MESH MODEL
+        const mesh_model = new Model(gl, {
+            id: `${this.props.id}-mesh`,
+            vs: vsShader,
+            fs: fsShader,
+            geometry: new Geometry({
+                drawMode: this.props.mesh.drawMode,
+                attributes: {
+                    positions: this.props.mesh.attributes.positions,
+                    normals: this.props.mesh.attributes.normals,
+                    properties: this.props.mesh.attributes.properties,
+                    vertex_indexs: this.props.mesh.attributes.vertex_indexs,
+                },
+                vertexCount: this.props.mesh.vertexCount,
+                indices: this.props.mesh.indices,
+            }),
+            modules: [project, picking, phongLighting],
+            isInstanced: false, // This only works when set to false.
+        });
+
+        // MESH LINES
+        const mesh_lines_model = new Model(gl, {
+            id: `${this.props.id}-lines`,
+            vs: vsLineShader,
+            fs: fsLineShader,
+            geometry: new Geometry(this.props.meshLines),
+            modules: [project, picking],
+            isInstanced: false,
+        });
+
+        return [mesh_model, mesh_lines_model];
+    }
+
+    // Signature from the base class, eslint doesn't like the any type.
+    // eslint-disable-next-line
+    draw(args: any): void {
+        if (!this.state["models"]) {
+            return;
+        }
+
+        const { uniforms, context } = args;
+        const { gl } = context;
+
+        const contourReferencePoint = this.props.contours[0] ?? -1.0;
+        const contourInterval = this.props.contours[1] ?? -1.0;
+        const isContoursDepth = this.props.isContoursDepth;
+
+        const [model_mesh, mesh_lines_model] = this.state["models"];
+
+        const valueRangeMin = this.props.propertyValueRange[0] ?? 0.0;
+        const valueRangeMax = this.props.propertyValueRange[1] ?? 1.0;
+
+        // If specified color map will extend from colorMapRangeMin to colorMapRangeMax.
+        // Otherwise it will extend from valueRangeMin to valueRangeMax.
+        const colorMapRangeMin = this.props.colorMapRange?.[0] ?? valueRangeMin;
+        const colorMapRangeMax = this.props.colorMapRange?.[1] ?? valueRangeMax;
+
+        const isClampColor: boolean =
+            this.props.colorMapClampColor !== undefined &&
+            this.props.colorMapClampColor !== true &&
+            this.props.colorMapClampColor !== false;
+        let colorMapClampColor = isClampColor
+            ? this.props.colorMapClampColor
+            : [0, 0, 0];
+
+        // Normalize to [0,1] range.
+        colorMapClampColor = (colorMapClampColor as Color).map(
+            (x) => (x ?? 0) / 255
+        );
+
+        const isColorMapClampColorTransparent: boolean =
+            (this.props.colorMapClampColor as boolean) === false;
+
+        const smoothShading = this.props.smoothShading;
+
+        gl.enable(GL.POLYGON_OFFSET_FILL);
+        if (!this.props.depthTest) {
+            gl.disable(GL.DEPTH_TEST);
+        }
+
+        gl.polygonOffset(1, 1);
+        model_mesh
+            .setUniforms({
+                ...uniforms,
+                contourReferencePoint,
+                contourInterval,
+                isContoursDepth,
+                colormap: new Texture2D(context.gl, {
+                    width: 256,
+                    height: 1,
+                    format: GL.RGB,
+                    data: getImageData(
+                        this.props.colorMapName,
+                        (this.context as DeckGLLayerContext).userData
+                            .colorTables,
+                        this.props.colorMapFunction
+                    ),
+                    parameters: DEFAULT_TEXTURE_PARAMETERS,
+                }),
+                valueRangeMin,
+                valueRangeMax,
+                colorMapRangeMin,
+                colorMapRangeMax,
+                colorMapClampColor,
+                isColorMapClampColorTransparent,
+                isClampColor,
+                smoothShading,
+            })
+            .draw();
+        gl.disable(GL.POLYGON_OFFSET_FILL);
+
+        if (!this.props.depthTest) {
+            gl.enable(GL.DEPTH_TEST);
+        }
+
+        if (this.props.gridLines) {
+            mesh_lines_model.draw();
+        }
+    }
+
+    decodePickingColor(): number {
+        return 0;
+    }
+
+    getPickingInfo({ info }: { info: PickingInfo }): LayerPickInfo {
+        if (!info.color) {
+            return info;
+        }
+
+        const layer_properties: PropertyDataType[] = [];
+
+        // Note these colors are in the  0-255 range.
+        const r = info.color[0];
+        const g = info.color[1];
+        const b = info.color[2];
+
+        const vertexIndex = 256 * 256 * r + 256 * g + b;
+
+        const vertexs = this.props.mesh.attributes.positions.value;
+        const depth = -vertexs[3 * vertexIndex + 2];
+        layer_properties.push(createPropertyData("Depth", depth));
+
+        const properties = this.props.mesh.attributes.properties.value;
+        const property = properties[vertexIndex];
+        layer_properties.push(createPropertyData("Property", property));
+
+        return {
+            ...info,
+            properties: layer_properties,
+        };
+    }
+}
+
+privateMapLayer.layerName = "privateMapLayer";
+privateMapLayer.defaultProps = defaultProps;

package/src/layers/map/vertex.glsl.ts

@@ -0,0 +1,45 @@
+const vsShader = `\
+#version 300 es
+#define SHADER_NAME vertex-shader
+
+precision highp float;
+
+// Primitive attributes
+in vec3 positions;
+in float properties;
+in vec3 normals;
+in vec3 colors;
+
+in int vertex_indexs;
+flat out int vertex_indexs_;
+
+
+// Outputs to fragment shader
+out vec2 vTexCoord;
+out vec3 cameraPosition;
+out vec3 normals_commonspace;
+out vec4 position_commonspace;
+out vec4 vColor;
+out vec3 worldPos;
+out float property;
+
+
+void main(void) {
+   cameraPosition = project_uCameraPosition;
+
+   worldPos = positions;
+
+   normals_commonspace = normals;
+
+   vertex_indexs_ = vertex_indexs;
+
+   vColor = vec4(colors.rgb, 1.0);
+
+   property = properties;
+
+   position_commonspace = vec4(project_position(positions), 0.0);
+   gl_Position = project_common_position_to_clipspace(position_commonspace);
+}
+`;
+
+export default vsShader;

package/src/layers/map/vertex_lines.glsl.ts

@@ -0,0 +1,15 @@
+export default `\
+#version 300 es
+#define SHADER_NAME vertex-lines-shader
+
+precision highp float;
+
+in vec3 positions;
+
+out vec4 position_commonspace;
+
+void main(void) {
+   vec3 position_commonspace = project_position(positions);
+   gl_Position = project_common_position_to_clipspace(vec4(position_commonspace, 0.0));
+}
+`;