@niivue/niivue 0.44.0 → 0.44.2-dev.1

package/src/nvmesh.ts

@@ -1313,6 +1313,102 @@ export class NVMesh {
     this.updateMesh(gl) // apply the new properties...
   }
 
+  hierarchicalOrder(): number {
+    const V0 = 12
+    const F0 = 20
+    const nF = this.tris.length / 3
+    const order = Math.log(nF / F0) / Math.log(4)
+    // Sanity checks
+    if (nF !== Math.pow(4, order) * F0) {
+      return NaN
+    }
+    const nV = this.pts.length / 3
+    if (nV !== Math.pow(4, order) * (V0 - 2) + 2) {
+      return NaN
+    }
+    // next checks are in case FreeSurfer was optimized with more local face indices
+    // for an example see BrainMesh_ICBM152.lh.mz3
+    for (let i = 0; i < 15; i += 3) {
+      if (this.tris[i] !== 0) {
+        return NaN
+      }
+    }
+    for (let i = 15; i < 24; i += 3) {
+      if (this.tris[i] !== 3) {
+        return NaN
+      }
+    }
+    for (let i = 24; i < 30; i += 3) {
+      if (this.tris[i] !== 4) {
+        return NaN
+      }
+    }
+    return order
+  }
+
+  decimateFaces(n: number, ntarget: number): void {
+    let fac = this.tris
+    // Constants for the icosahedron
+    const V0 = 12
+    const F0 = 20
+    for (let j = n - 1; j >= ntarget; j--) {
+      const nVjprev = Math.pow(4, j + 1) * (V0 - 2) + 2
+      const nVj = Math.pow(4, j) * (V0 - 2) + 2
+      const nFjprev = fac.length / 3 // = 4^(j+1)*F0
+      const nFj = Math.pow(4, j) * F0
+
+      console.log(`order ${j + 1} -> ${j} vertices ${nVjprev} -> ${nVj} faces ${nFjprev} -> ${nFj}`)
+
+      const remap = Array.from({ length: nVjprev }, (_, i) => i + 1)
+
+      for (let i = 0; i < nFjprev; i++) {
+        const v1 = fac[3 * i]
+        const v2 = fac[3 * i + 1]
+        const v3 = fac[3 * i + 2]
+        remap[v1 - 1] = Math.min(remap[v1 - 1], v2, v3)
+      }
+
+      const facJ = new Uint32Array(nFj * 3)
+      for (let i = 0; i < nFj; i++) {
+        facJ[3 * i] = remap[fac[3 * i] - 1]
+        facJ[3 * i + 1] = remap[fac[3 * i + 1] - 1]
+        facJ[3 * i + 2] = remap[fac[3 * i + 2] - 1]
+      }
+      fac = facJ
+    }
+    this.tris = new Uint32Array(fac)
+  }
+
+  // internal function simplifies FreeSurfer triangulated mesh and overlays
+  decimateHierarchicalMesh(gl: WebGL2RenderingContext, order: number = 4): boolean {
+    const inputOrder = this.hierarchicalOrder()
+    if (isNaN(inputOrder)) {
+      log.warn('Unable to decimate mesh: it does not have a hierarchical structure')
+      return false
+    }
+    if (order >= inputOrder) {
+      log.warn(`Unable to decimate mesh: input order (${inputOrder}) must be larger than downsampled order (${order})`)
+      return false
+    }
+    const inputVLength = this.pts.length / 3
+    const V0 = 12
+    const nV = Math.pow(4, order) * (V0 - 2) + 2
+    this.pts = new Float32Array(this.pts.slice(0, nV * 3))
+    this.decimateFaces(inputOrder, order)
+    if (this.layers && this.layers.length > 0) {
+      for (let i = 0; i < this.layers.length; i++) {
+        const layer = this.layers[i]
+        if (layer.values instanceof Float32Array || layer.values.length !== inputVLength) {
+          layer.values = new Float32Array(layer.values.slice(0, nV))
+        } else {
+          log.warn(`decimation logic needs to be updated`)
+        }
+      }
+    }
+    this.updateMesh(gl) // apply the new properties...
+    return true
+  }
+
   // adjust attributes of a mesh layer. invoked by niivue.setMeshLayerProperty()
   // TODO this method is a bit too generic
   setLayerProperty(

package/src/shader-srcs.ts

@@ -719,6 +719,47 @@ void main() {
 	color = lineColor;
 }`
 
+export const fragRectOutlineShader = `#version 300 es
+#line 723
+precision highp int;
+precision highp float;
+
+uniform vec4 lineColor;
+uniform vec4 leftTopWidthHeight;
+uniform float thickness; // line thickness in pixels
+uniform vec2 canvasWidthHeight;
+
+out vec4 color;
+
+void main() {
+    // fragment position in screen coordinates
+    vec2 fragCoord = gl_FragCoord.xy;
+
+    // canvas height
+    float canvasHeight = canvasWidthHeight.y;
+
+    // 'top' and 'bottom' to match gl_FragCoord.y coordinate system
+    float top = canvasHeight - leftTopWidthHeight.y;
+    float bottom = top - leftTopWidthHeight.w;
+
+    // left and right edges
+    float left = leftTopWidthHeight.x;
+    float right = left + leftTopWidthHeight.z;
+
+    bool withinLeft = fragCoord.x >= left && fragCoord.x <= left + thickness;
+    bool withinRight = fragCoord.x <= right && fragCoord.x >= right - thickness;
+    bool withinTop = fragCoord.y <= top && fragCoord.y >= top - thickness;
+    bool withinBottom = fragCoord.y >= bottom && fragCoord.y <= bottom + thickness;
+
+    bool isOutline = withinLeft || withinRight || withinTop || withinBottom;
+
+    if (isOutline) {
+        color = lineColor;
+    } else {
+        discard; 
+    }
+}`
+
 export const vertColorbarShader = `#version 300 es
 #line 490
 layout(location=0) in vec3 pos;
@@ -1207,11 +1248,11 @@ uniform mat4 mvpMtx;
 uniform mat4 normMtx;
 out vec4 vClr;
 out vec3 vN;
-out vec4 vP;
+out vec4 vPc;
 void main(void) {
 	vec3 lightPosition = vec3(0.0, 0.0, -10.0);
-	vP = vec4(pos, 1.0);
-	gl_Position = mvpMtx * vP;
+	vPc = mvpMtx * vec4(pos, 1.0);
+	gl_Position = vPc;
 	vN = normalize((normMtx * vec4(norm.xyz,1.0)).xyz);
 	//vV = -vec3(modelMtx*vec4(pos,1.0));
 	vClr = clr;
@@ -1368,6 +1409,46 @@ void main() {
 	color = vec4(d3 + s3 + s, opacity);
 }`
 
+// https://thorium.rocks/media/curves/curvaceous.html
+export const fragMeshShaderCrevice = `#version 300 es
+precision highp int;
+precision highp float;
+uniform float opacity;
+in vec4 vClr;
+in vec3 vN;
+in vec4 vPc;
+out vec4 color;
+void main() {
+	vec3 n = normalize(vN);
+	// Compute curvature
+	vec3 dx = dFdx(n);
+	vec3 dy = dFdy(n);
+	vec3 xneg = n - dx;
+	vec3 xpos = n + dx;
+	vec3 yneg = n - dy;
+	vec3 ypos = n + dy;
+	float depth = length(vPc.xyz);
+	float curv = (cross(xneg, xpos).y - cross(yneg, ypos).x) / depth;
+	//at this stage 0.5 for flat, with valleys dark and ridges bright
+	curv = 1.0 - (curv + 0.5);
+	//clamp
+	curv =  min(max(curv, 0.0), 1.0);
+	// easing function
+	curv = pow(curv, 0.5);
+	//modulate ambient and diffuse with curvature
+	vec3 r = vec3(0.0, 0.0, 1.0); //rayDir: for orthographic projections moving in Z direction (no need for normal matrix)
+	float ambient = 0.6;
+	float diffuse = 0.6;
+	float specular = 0.2;
+	float shininess = 10.0;
+	vec3 lightPosition = vec3(0.0, 10.0, -2.0);
+	vec3 l = normalize(lightPosition);
+	float lightNormDot = dot(n, l);
+	vec3 a = vClr.rgb * ambient * curv;
+	vec3 d = max(lightNormDot, 0.0) * vClr.rgb * diffuse;
+	float s = specular * pow(max(dot(reflect(l, n), r), 0.0), shininess);
+	color = vec4(a + d + s, opacity);
+}`
 // Phong: default
 export const fragMeshShader = `#version 300 es
 precision highp int;

package/src/types.ts

@@ -152,3 +152,16 @@ export type NiiVueLocation = {
   vox: vec3
   xy: [number, number]
 }
+
+export type SyncOpts = {
+  '3d'?: boolean
+  '2d'?: boolean
+  zoomPan?: boolean
+  cal_min?: boolean
+  cal_max?: boolean
+  gamma?: boolean
+  useSliceOffset?: boolean
+  sliceType?: boolean
+  crosshair?: boolean
+  clipPlane?: boolean
+}