@webviz/subsurface-viewer 0.0.1-alpha.1 → 0.0.2-alpha.2

package/src/layers/terrain/terrainMapLayer.ts

@@ -1,334 +0,0 @@
-import {
-    SimpleMeshLayer,
-    SimpleMeshLayerProps,
-} from "@deck.gl/mesh-layers/typed";
-import { COORDINATE_SYSTEM } from "@deck.gl/core/typed";
-import { Color, PickingInfo } from "@deck.gl/core/typed";
-import fsShader from "./terrainmap.fs.glsl";
-import GL from "@luma.gl/constants";
-import { Texture2D } from "@luma.gl/webgl";
-import { DeckGLLayerContext } from "../../components/Map";
-import { colorTablesArray, rgbValues } from "@emerson-eps/color-tables/";
-import { createDefaultContinuousColorScale } from "@emerson-eps/color-tables/dist/component/Utils/legendCommonFunction";
-import {
-    createPropertyData,
-    PropertyDataType,
-    colorMapFunctionType,
-} from "../utils/layerTools";
-
-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 Material =
-    | {
-          ambient: number;
-          diffuse: number;
-          shininess: number;
-          specularColor: [number, number, number];
-      }
-    | boolean;
-
-export const DECODER = {
-    rScaler: 256 * 256,
-    gScaler: 256,
-    bScaler: 1,
-    offset: 0,
-};
-
-function getImageData(
-    colorMapName: string,
-    colorTables: colorTablesArray,
-    colorMapFunction: colorMapFunctionType | undefined
-) {
-    const isColorMapFunctionDefined = typeof colorMapFunction !== "undefined";
-    const isColorMapNameDefined = !!colorMapName;
-
-    const data = new Uint8Array(256 * 3);
-
-    const defaultColorMap = createDefaultContinuousColorScale;
-
-    const colorMap = isColorMapFunctionDefined
-        ? colorMapFunction
-        : isColorMapNameDefined
-        ? (value: number) => rgbValues(value, colorMapName, colorTables)
-        : defaultColorMap();
-
-    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 type DataItem = {
-    position: [number, number];
-    angle: number;
-    color: [number, number, number];
-};
-
-export type TerrainMapLayerData = [DataItem?];
-
-export interface TerrainMapLayerProps<D> extends SimpleMeshLayerProps<D> {
-    // texture as ImageData.
-    textureImageData: ImageData;
-
-    // mesh  as ImageData.
-    meshImageData: ImageData;
-
-    // Min and max of map height values values.
-    meshValueRange: [number, number];
-
-    // Contourlines reference point and interval.
-    contours: [number, number];
-
-    // Contourlines may be calculated either on depth/z-value or on property/texture value
-    isContoursDepth: boolean;
-
-    // Name of color map.
-    colorMapName: string;
-
-    // Optional function property.
-    // If defined this function will override the color map.
-    // Takes a value in the range [0,1] and returns a color.
-    colorMapFunction?: colorMapFunctionType;
-
-    // Min and max property values.
-    propertyValueRange: [number, number];
-
-    // Use color map in this range.
-    colorMapRange: [number, number];
-
-    // Clamp colormap to this color at ends.
-    // Given as array of three values (r,g,b) e.g: [255, 0, 0]
-    // If not set or set to true, it will clamp to color map min and max values.
-    // If set to false the clamp color will be completely transparent.
-    colorMapClampColor: Color | undefined | boolean;
-
-    depthTest: boolean;
-}
-
-const defaultProps = {
-    data: [{ position: [0, 0], angle: 0, color: [255, 0, 0, 0] }], // dummy data
-
-    getPosition: (d: DataItem) => d.position,
-    getColor: (d: DataItem) => d.color,
-    getOrientation: (d: DataItem): [number, number, number] => [0, d.angle, 0],
-    contours: [-1, -1],
-    colorMapName: "",
-    propertyValueRange: [0.0, 1.0],
-    isContoursDepth: true,
-    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
-    textureImageData: { value: null, type: "object", async: true },
-    meshImageData: { value: null, type: "object", async: true },
-    meshValueRange: [0.0, 1.0],
-    depthTest: true,
-};
-
-// This is a private layer used only by the composite Map3DLayer.
-// It is an extension of SimpleMeshLayer but with modified fragment shader
-// so that the texture pixel values can be used as lookup in  a supplied color map.
-export default class TerrainMapLayer extends SimpleMeshLayer<
-    TerrainMapLayerData,
-    TerrainMapLayerProps<TerrainMapLayerData>
-> {
-    properties?: PropertyDataType[];
-    // Signature from the base class, eslint doesn't like the any type.
-    // eslint-disable-next-line
-    draw({ uniforms, context }: any): void {
-        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 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;
-
-        if (!this.props.depthTest) {
-            gl.disable(GL.DEPTH_TEST);
-        }
-
-        super.draw({
-            uniforms: {
-                ...uniforms,
-                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,
-                contourReferencePoint,
-                contourInterval,
-                isContoursDepth,
-                colorMapClampColor,
-                isColorMapClampColorTransparent,
-                isClampColor,
-            },
-        });
-
-        if (!this.props.depthTest) {
-            gl.enable(GL.DEPTH_TEST);
-        }
-    }
-
-    getShaders(): unknown {
-        const parentShaders = super.getShaders();
-        // Overwrite the default fragment shader with ours.
-        parentShaders.fs = fsShader;
-
-        return {
-            ...parentShaders,
-
-            // Inject this into vertex shader. Vi want to export vertex world position to
-            // fragment shader for making contour lines.
-            inject: {
-                "vs:#decl": `
-                  out vec3 worldPos;
-                `,
-
-                "vs:#main-start": `
-                   worldPos = positions;
-                `,
-            },
-        };
-    }
-
-    decodePickingColor(): number {
-        return 0;
-    }
-
-    getPickingInfo({ info }: { info: PickingInfo }): PickingInfo & {
-        properties?: PropertyDataType[];
-    } {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const pickColor = info.color as Color;
-        if (!pickColor) {
-            return info;
-        }
-
-        // Texture coordinates.
-        const s = pickColor[0] / 255.0;
-        const t = pickColor[1] / 255.0;
-
-        const is_outside: boolean = pickColor[2] == 0;
-        if (is_outside) {
-            // Mouse is outside the non-transparent part of the map.
-            return info;
-        }
-
-        // MESH HEIGHT VALUE.
-        const meshImageData: ImageData = this.props.meshImageData;
-        const isMeshImageData = meshImageData !== null;
-        const value_mesh = isMeshImageData
-            ? getValue(meshImageData, s, t, DECODER)
-            : 0;
-
-        // TEXTURE PROPERTY VALUE.
-        const textureImageData: ImageData = this.props.textureImageData;
-        const value_property = getValue(textureImageData, s, t, DECODER);
-
-        const layer_properties: PropertyDataType[] = [];
-        layer_properties.push(
-            getMapProperty(
-                "Property",
-                value_property,
-                this.props.propertyValueRange
-            ),
-            isMeshImageData
-                ? getMapProperty("Depth", value_mesh, this.props.meshValueRange)
-                : { name: "Depth", value: 0 }
-        );
-
-        return {
-            ...info,
-            properties: layer_properties,
-        };
-    }
-}
-
-TerrainMapLayer.layerName = "TerrainMapLayer";
-TerrainMapLayer.defaultProps = defaultProps;
-
-//================= Local help functions. ==================
-
-function getMapProperty(
-    name: string,
-    value: number,
-    value_range: [number, number]
-): PropertyDataType {
-    // Remap the [0, 1] decoded value to property value range.
-    const [min, max] = value_range;
-
-    const floatScaler = 1.0 / (256.0 * 256.0 * 256.0 - 1.0);
-    const scaled_value = value * floatScaler;
-
-    value = scaled_value * (max - min) + min;
-    return createPropertyData(name, value);
-}
-
-function getValue(
-    imageData: ImageData,
-    s: number,
-    t: number,
-    decoder: { rScaler: number; gScaler: number; bScaler: number }
-): number {
-    const int_view = new Uint8ClampedArray(
-        imageData.data,
-        0,
-        imageData.data.length
-    );
-
-    const w = imageData.width;
-    const h = imageData.height;
-    const j = Math.min(Math.floor(w * s), w - 1);
-    const i = Math.min(Math.floor(h * t), h - 1);
-
-    const pixelNo = i * w + j;
-    const r = int_view[pixelNo * 4 + 0] * decoder.rScaler;
-    const g = int_view[pixelNo * 4 + 1] * decoder.gScaler;
-    const b = int_view[pixelNo * 4 + 2] * decoder.bScaler;
-    const value = r + g + b;
-
-    return value;
-}

package/src/layers/terrain/terrainmap.fs.glsl.ts

@@ -1,134 +0,0 @@
-const fsShader = `#version 300 es
-#define SHADER_NAME terrainmap-shader
-
-precision highp float;
-
-uniform bool hasTexture;
-uniform sampler2D sampler;
-uniform bool flatShading;
-uniform float opacity;
-
-uniform bool isContoursDepth;
-
-uniform float contourReferencePoint;
-uniform float contourInterval;
-
-in vec2 vTexCoord;
-in vec3 cameraPosition;
-in vec3 normals_commonspace;
-in vec4 position_commonspace;
-in vec4 vColor;
-in vec4 positions;
-
-out vec4 fragColor;
-
-in vec3 worldPos; // we export this from vertex shader (by injecting into it).
-
-uniform sampler2D colormap;
-
-uniform float valueRangeMin;
-uniform float valueRangeMax;
-uniform float colorMapRangeMin;
-uniform float colorMapRangeMax;
-
-uniform vec3 colorMapClampColor;
-uniform bool isClampColor;
-uniform bool isColorMapClampColorTransparent;
-
-
-void main(void) {
-   geometry.uv = vTexCoord;
-
-   vec3 normal;
-   if (flatShading) {
-#ifdef DERIVATIVES_AVAILABLE
-      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
-#else
-      normal = vec3(0.0, 0.0, 1.0);
-#endif
-   } else {
-      normal = normals_commonspace;
-   }
-
-   vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;
-
-   float texture_alpha = color.a;
-
-   // Discard transparent pixels.
-   if (!picking_uActive && color.w < 0.99) {
-         discard;
-         return;
-   }
-
-   // Picking pass.
-   if (picking_uActive) {
-      // Send texture coordinates.
-      float s = vTexCoord.x;
-      float t = vTexCoord.y;
-      float b = texture_alpha > 0.95 ? 255.0 : 0.0;
-
-      fragColor = vec4(s, t, b, 1.0);
-      return;
-   }
-
-   float propertyValue = 0.0;
-   if (hasTexture) {
-      float opcacity = color.w;
-      float floatScaler =  1.0 / (256.0 * 256.0 * 256.0 - 1.0);
-      vec3 rgb = color.rgb;
-      rgb *= vec3(16711680.0, 65280.0, 255.0); //255*256*256, 255*256, 255
-      float propertyValue_norm = (rgb.r + rgb.g + rgb.b) * floatScaler; // propertyValue_norm will be in range [0-1]
-
-      // If colorMapRangeMin/Max specified, color map will span this interval.
-      propertyValue  = propertyValue_norm * (valueRangeMax - valueRangeMin) + valueRangeMin;
-      float x = (propertyValue - colorMapRangeMin) / (colorMapRangeMax - colorMapRangeMin);
-;
-      if (x < 0.0 || x > 1.0) {
-         // Out of range. Use clampcolor.
-         if (isClampColor) {
-            color = vec4(colorMapClampColor.rgb, 1.0);
-
-         }
-         else if (isColorMapClampColorTransparent) {
-            discard;
-            return;
-         }
-         else {
-            // Use min/max color to clamp.
-            x = max(0.0, x);
-            x = min(1.0, x);
-
-            color = texture2D(colormap, vec2(x, 0.5));
-            color.a = opcacity;
-         }
-      }
-      else {
-         color = texture2D(colormap, vec2(x, 0.5));
-         color.a = opcacity;
-      }
-   }
-
-   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;
-   if (is_contours) {
-      // Contours are made of either depths or properties.
-      float val =  (hasTexture && !isContoursDepth) ? (propertyValue - contourReferencePoint) / contourInterval
-                                                    : (abs(worldPos.z) - contourReferencePoint) / contourInterval;
-
-      float f  = fract(val);
-      float df = fwidth(val);
-
-      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.
-      float c = smoothstep(0.0, df * 2.0, f);
-
-      color = color * vec4(c, c, c, 1.0);
-   }
-
-   // Use normal lighting.
-   vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
-   fragColor = vec4(lightColor, color.a * opacity);
-
-   DECKGL_FILTER_COLOR(fragColor, geometry);
-}
-`;
-
-export default fsShader;

package/src/layers/triangle/fragment.fs.glsl.ts

@@ -1,126 +0,0 @@
-const fsShader = `#version 300 es
-#define SHADER_NAME terrainmap-shader
-
-precision highp float;
-
-uniform bool isContoursDepth;
-uniform float contourReferencePoint;
-uniform float contourInterval;
-
-in vec2 vTexCoord;
-in vec3 cameraPosition;
-in vec3 normals_commonspace;
-in vec4 position_commonspace;
-in vec3 worldPos;
-in float property;
-
-out vec4 fragColor;
-
-uniform sampler2D colormap;
-uniform vec4 uColor;
-uniform bool smoothShading;
-
-
-vec3 getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-    
-   vec3 halfway_direction = normalize(light_direction + view_direction);   
-   float lambertian = abs(dot(light_direction, normal_worldspace));
-
-   float specular_angle = abs(dot(normal_worldspace, halfway_direction));
-
-   float specular = pow(specular_angle, lighting_uShininess);       
-   return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;    
-}
-
-vec3 getLightColor(vec3 surfaceColor,vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-
-  vec3 lightColor = surfaceColor;
-
-  if (lighting_uEnabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uPointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_uPointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting_uDirectionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
-      lightColor += getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  return lightColor;
-}
-
-void main(void) {
-   //geometry.uv = vTexCoord;
-
-   vec3 normal = normals_commonspace;
-
-   if (!smoothShading) {
-      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
-   } 
-   
-   //Picking pass.
-   if (picking_uActive) {
-      // Readout is surface height (z value).
-      float range = 10000.0;  // May represent depths in range 0 - 10000 meter.
-
-      // Express in 255 system.
-      float depth = abs(worldPos.z);
-      float depthScaled = (256.0 * 256.0 * 256.0) * (depth / range); // scaled to within max range in 256 system.
-
-      float r = 0.0;
-      float g = 0.0;
-      float b = 0.0;
-
-      if (depthScaled >= (256.0 * 256.0) - 1.0) {
-         r = floor(depthScaled / (256.0 * 256.0));
-         depthScaled -= r * (256.0 * 256.0);
-      }
-
-      if (depthScaled >= 256.0 - 1.0) {
-         g = floor(depthScaled / 256.0);
-         depthScaled -= g * 256.0;
-      }
-
-      b = floor(depthScaled);
-
-      fragColor = vec4(r / 255.0, g / 255.0, b / 255.0,  1.0);
-      return;
-   }
-
-   vec4 color = uColor;
-
-   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;
-   if (is_contours) {
-      // Contours are made of either depths or properties.
-      float val = (abs(worldPos.z) - contourReferencePoint) / contourInterval;
-
-      float f  = fract(val);
-      float df = fwidth(val);
-
-      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.
-      float c = smoothstep(0.0, df * 2.0, f);
-
-      color = color * vec4(c, c, c, 1.0);
-   }
-
-   // Use normal lighting. This has no effect if "material" property is not set.
-   vec3 lightColor = getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
-   fragColor = vec4(lightColor, 1.0);
-
-   DECKGL_FILTER_COLOR(fragColor, geometry);
-}
-`;
-
-export default fsShader;

package/src/layers/triangle/fragment_lines.glsl.ts

@@ -1,21 +0,0 @@
-const fragmentShader = `\
-#version 300 es
-#define SHADER_NAME graph-layer-fragment-shader
-
-precision highp float;
-
-out vec4 fragColor;
-
-void main(void) {
-  
-  // Picking pass.
-  if (picking_uActive) {
-    discard;
-    return;
-  }
-
-  fragColor = vec4(0.0, 0.0, 0.0, 1.0);
-}
-`;
-
-export default fragmentShader;