Changeset 22758 for issm/trunk/src/m/plot/plot_quiver.js

Timestamp:

05/10/18 10:24:27 (7 years ago)

Author:

Mathieu Morlighem

Message:

merged trunk-jpl and trunk for revision 22757

Location:

issm/trunk

Files:

• . (modified) (1 prop)
• src (modified) (1 prop)
• src/m/plot/plot_quiver.js (modified) (4 diffs)

issm/trunk/src/m/plot/plot_quiver.js

@@ -1 @@
-function plot_quiver(md, options, canvas, updateVel) { //{{{
+function plot_quiver(md, options, canvas, noCacheNodesOverride) { //{{{
         //PLOT_QUIVER - quiver plot with colors
         //
@@ -7 +7 @@
         //   See also: PLOTMODEL, PLOT_MANAGER
 
+        //Disabling for now, since quivers are "sticky" - once turned on, they won't turn off. This is due to cachenodes, but should find better way to handle it.
+        return;
+        
+        if ('quiver' in  canvas.nodes && noCacheNodesOverride && options.getfieldvalue('cachenodes','on') === 'on') return;
+        
         //{{{ declare variables:
-        var vertices = [];
-        var indices = [];
-        var colors = [];
-        var xmin, xmax;
-        var ymin, ymax;
-        var zmin, zmax;
-        var scale, matrixscale, vertexscale;
-        
         //Process data and model
-        var meshresults = processmesh(md,[], options);
-
+        var meshresults = processmesh(md, [], options);
         var x = meshresults[0]; 
         var y = meshresults[1]; 
@@ -25 +21 @@
         var is2d = meshresults[4]; 
         var isplanet = meshresults[5];
-        var v = updateVel != undefined ? updateVel.vel : md.initialization.vel;
-        var vx = updateVel != undefined ? updateVel.vx : md.initialization.vx;
-        var vy = updateVel != undefined ? updateVel.vy : md.initialization.vy;
+        if (md.mesh.classname() !== 'mesh3dsurface') z = md.geometry.surface;
                 
-        //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
-        if (!md.geometry.surface) {
-                md.geometry.surface=NewArrayFill(md.mesh.x.length, 0);
-        }
-        if (md.mesh.classname() == 'mesh3dsurface') {
-                matrixscale = 1;
-                vertexscale = options.getfieldvalue('heightscale', 1);
+        //Compute coordinates and data range:
+        var xlim = options.getfieldvalue('xlim', [ArrayMin(x), ArrayMax(x)]);
+        var ylim = options.getfieldvalue('ylim', [ArrayMin(y), ArrayMax(y)]);
+        var zlim = options.getfieldvalue('zlim', [ArrayMin(z), ArrayMax(z)]);
+
+        //Only displaying velocity fields for now
+        var v = VESL.Helpers.isEmptyOrUndefined(md.results) ?  md.initialization.vel : md.results[canvas.animation.frame].Vel;
+        var vx = VESL.Helpers.isEmptyOrUndefined(md.results) ? md.initialization.vx : md.results[canvas.animation.frame].Vx;
+        var vy = VESL.Helpers.isEmptyOrUndefined(md.results) ? md.initialization.vy : md.results[canvas.animation.frame].Vy;
+
+        //Handle heightscale
+        var vertices, scale;
+        if (md.mesh.classname() !== 'mesh3dsurface') {
+                vertices = [x, y, z];
+                scale = [1, 1, options.getfieldvalue('heightscale', 1)];
         }
         else {
-                if (md.geometry.surface) {
-                        z=md.geometry.surface;
-                }       
-                matrixscale = options.getfieldvalue('heightscale', 1);
-                vertexscale = 0;
+                vertices = Node.prototype.scaleVertices(md, x, y, z, elements, options.getfieldvalue('heightscale', 1), options.getfieldvalue('maskregion',{'enabled':false}));
+                scale = [1, 1, 1];
         }
-        //}}}
-
-        //Compute coordinates and data range:
-        var modelxlim = [ArrayMin(x), ArrayMax(x)];
-        var modelylim = [ArrayMin(y), ArrayMax(y)];
-        var modelzlim = [ArrayMin(z), ArrayMax(z)];
-        var xlim = options.getfieldvalue('xlim', modelxlim);
-        var ylim = options.getfieldvalue('ylim', modelylim);
-        var zlim = options.getfieldvalue('zlim', modelzlim);
-        xmin = xlim[0];
-        xmax = xlim[1];
-        ymin = ylim[0];
-        ymax = ylim[1];
-        zmin = zlim[0];
-        zmax = zlim[1];
-
+        
         //Compute gl variables:
-        var gl = canvas.gl;
-        var node = Node(gl);
-        canvas.nodes["velocity"] = node;
-        node.name = "quiver";
-        node.shaderName = "Colored";
-        node.shader = gl.shaders[node.shaderName];
-        node.lineWidth = options.getfieldvalue('linewidth', 1);
-        node.scale = [1, 1, matrixscale];
-        node.rotation = [-90, 0, 0];
-        node.translation = [0, 0, 0];
-        node.center = [(xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2];
-        node.drawMode = gl.LINES;
-        node.useIndexBuffer = false;
-        node.drawOrder = 0;
-        node.maskEnabled = options.getfieldvalue('innermask','off') == 'on';
-        node.maskHeight = options.getfieldvalue('innermaskheight', 150.0)*options.getfieldvalue('heightscale', 1);
-        node.maskColor = options.getfieldvalue('innermaskcolor',[0.0, 0.0, 1.0, 1.0]);
-        updateModelMatrix(node);
-
-        //retrieve some options
-        var edgecolor=new RGBColor(options.getfieldvalue('edgecolor','black'));
-        if (edgecolor.ok) edgecolor = [edgecolor.r/255.0, edgecolor.g/255.0, edgecolor.b/255.0, 1.0];
-        else throw Error(sprintf("s%s%s\n","initWebGL error message: cound not find out edgecolor color for curent canvas ", canvas));
-
+        var edgecolor = options.getfieldvalue('edgecolor', 'black');
+        var node = new Node(
+                'canvas', canvas,
+                'options', options,
+                'name', 'quiver',
+                'shaderName', 'Colored',
+                'alpha', options.getfieldvalue('alpha', 1.0),
+                //'center', [(xlim[0] + xlim[1]) / 2, (ylim[0] + ylim[1]) / 2, md.mesh.classname() === 'mesh3dsurface' ? (zlim[0] + zlim[1]) / 2 : zlim[0]],
+                'center', [(xlim[0] + xlim[1]) / 2, (ylim[0] + ylim[1]) / 2, (zlim[0] + zlim[1]) / 2],
+                'drawMode', canvas.gl.LINES,
+                'diffuseColor', edgecolor,
+                'lineWidth', options.getfieldvalue('linewidth', 1),
+                'maskEnabled', options.getfieldvalue('innermask','off') == 'on',
+                'maskHeight', options.getfieldvalue('innermaskheight', 150.0) / options.getfieldvalue('heightscale', 1),
+                'maskColor', options.getfieldvalue('innermaskcolor',[0.0, 0.0, 1.0, 1.0]),
+                'rotation', [-90, 0, 0],
+                'scale', scale
+        );
+        
+        
         //{{{ node plot
         if (elements[0].length==6){ //prisms
@@ -91 +71 @@
         }
         else{ //2D triangular elements
+                //Create arow vertices, and use vx/vy to determine rotation before adding to quiver mesh.
+                var verticesArrow = [vec3.fromValues(0.0, 0.0, 0.0), vec3.fromValues(1.0, 0.0, 0.0), vec3.fromValues(0.667, -0.167, 0.0), vec3.fromValues(1.0, 0.0, 0.0), vec3.fromValues(0.667, 0.166, 0.0), vec3.fromValues(1.0, 0.0, 0.0)];
+                
+                var newX = [];
+                var newY = [];
+                var newZ = [];
                 var xyz = vec3.create();
-                var xyz = vec3.create();
-                var direction = vec3.create();
                 var vertex = vec3.create();
-                var vertexBase = vec3.create();
-                var verticesArrow = [vec3.fromValues(0.0, 0.0, 0.0), vec3.fromValues(1.0, 0.0, 0.0), vec3.fromValues(0.667, -0.167, 0.0), vec3.fromValues(1.0, 0.0, 0.0), vec3.fromValues(0.667, 0.166, 0.0), vec3.fromValues(1.0, 0.0, 0.0)];
-                var magnitude;
-                var color = edgecolor;
                 var scaling = options.getfieldvalue('scaling', 1);
-                var scale;
-                for(var i = 0; i < x.length; i++){
-                        //Check for NaN values and remove from indices array as necessary, but preserve vertex array spacing
-                        if (isNaN(x[i]) || isNaN(y[i]) || isNaN(z[i])) continue;
-                        //Scale vertices
+                var heightScale = options.getfieldvalue('heightscale', 1);
+                var arrowScale;
+                var modelMatrix = mat4.create();
+                var scaleMatrix = mat4.create();
+                var rotationMatrix = mat4.create();
+                
+                for(var i = 0, iX = 0, iY = 0, iZ = 0; i < x.length; i++){
                         xyz = vec3.fromValues(x[i], y[i], z[i]);
-                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
-                        vec3.normalize(direction, xyz);
-                        vec3.scale(vertex, direction, magnitude);
-                        vec3.copy(vertexBase, vertex);
-                        
-                        scale = scaling*v[i];
-                        var modelMatrix = mat4.create();
-                        var scaleMatrix = mat4.create();
-                        var rotationMatrix = mat4.create();
-                        mat4.scale(scaleMatrix, scaleMatrix, vec3.fromValues(scale, scale, scale));
-                        mat4.rotate(rotationMatrix, rotationMatrix, Math.atan2(vy[i], vx[i]), [0.0, 0.0, 1.0]);
+                        arrowScale = v[i] * scaling;
+                        scaleMatrix = mat4.create();
+                        mat4.scale(scaleMatrix, mat4.create(), vec3.fromValues(arrowScale, arrowScale, arrowScale));
+                        mat4.rotate(rotationMatrix, mat4.create(), Math.atan2(vy[i], vx[i]), [0.0, 0.0, 1.0]);
                         mat4.multiply(modelMatrix, rotationMatrix, scaleMatrix);
-
-                        var temp = vec3.fromValues(0.0, 0.0, 0.0);
                         for (var j = 0; j < 6; j++){
                                 vec3.transformMat4(vertex, verticesArrow[j], modelMatrix);
-                                vec3.add(vertex, vertex, vertexBase);
-                                vertices[vertices.length] = vertex[0];
-                                vertices[vertices.length] = vertex[1];
-                                vertices[vertices.length] = vertex[2];
-                                
-                                colors[colors.length] = color[0];
-                                colors[colors.length] = color[1];
-                                colors[colors.length] = color[2];
-                                colors[colors.length] = color[3];
+                                vec3.add(vertex, vertex, xyz);
+                                newX[iX++] = vertex[0];
+                                newY[iY++] = vertex[1];
+                                newZ[iZ++] = vertex[2];
                         }
                 }
+                node.patch('Vertices', [newX, newY, newZ], 'FaceColor', 'none');
         }
         //}}}
-        node.mesh = GL.Mesh.load({vertices: vertices, colors: colors}, null, null, gl);
 } //}}}