Changeset 20471

Timestamp:

04/07/16 22:46:19 (9 years ago)

Author:

dlcheng

Message:

CHG: Modifying plot routines to handle NaN values by removing them from draw calls. Tentative fix for bug involving too many recursive concatenations for large models/meshes. Addressing shallow copies affecting model in processmesh.

Location:

issm/trunk-jpl/src/m/plot

Files:

• plot_mesh.js (modified) (3 diffs)
• plot_overlay.js (modified) (3 diffs)
• plot_quiver.js (modified) (1 diff)
• plot_unit.js (modified) (6 diffs)
• processmesh.js (modified) (2 diffs)

issm/trunk-jpl/src/m/plot/plot_mesh.js

@@ -9 +9 @@
         var indices = [];
         var colors = [];
-        var rgbcolor = [];
+        var nanindices = {};
         var xmin,xmax;
         var ymin,ymax;
@@ -85 +85 @@
                 var vertex = vec3.create();
                 var magnitude;
-                var color = [0.0, 0.0, 0.0, 1.0];
+                var color = [0.0, 0.0, 0.0, 1.0];       
+                                                x[0] = NaN;
+                x[1] = NaN;
+                x[2] = NaN;
+                x[3] = NaN;
+                x[4] = NaN;
+                x[5] = NaN;
+                x[6] = NaN;
+                x[7] = NaN;
+                x[8] = NaN;
+                x[9] = NaN;
+                x[10] = NaN;
+                x[11] = NaN;
+                x[12] = NaN;
+                x[13] = NaN;
+                x[14] = NaN;
+                x[15] = NaN;
+                x[16] = NaN;
+                x[17] = NaN;
+                x[18] = NaN;
+                x[19] = NaN;
+                x[20] = NaN;
+                x[21] = NaN;
+                x[22] = NaN;
+                x[23] = NaN;
+                x[24] = NaN;
+                x[25] = NaN;
+                x[26] = NaN;
+                x[27] = NaN;
+                x[28] = NaN;
+                x[29] = NaN;
+                x[30] = NaN;
+                x[31] = NaN;
+                x[32] = NaN;
+                x[33] = NaN;
+                x[34] = NaN;
+                x[35] = NaN;
+                x[36] = NaN;
+                x[37] = NaN;
+                x[38] = NaN;
+                x[39] = NaN;
+                x[310] = NaN;
+                x[311] = NaN;
+                x[312] = NaN;
+                x[313] = NaN;
+                x[314] = NaN;
+                x[315] = NaN;
+                x[316] = NaN;
+                x[317] = NaN;
+                x[318] = NaN;
+                x[319] = NaN;
+                x[320] = NaN;
+                x[321] = NaN;
+                x[322] = NaN;
+                x[323] = NaN;
+                x[324] = NaN;
+                x[325] = NaN;
+                x[326] = NaN;
+                x[327] = NaN;
+                x[328] = NaN;
+                x[329] = NaN;   
                 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])) {
+                                nanindices[i] = i;
+                                vertices.push.apply(vertices, vertex);
+                                continue;
+                        }
+                        //Scale vertices
+                        //Scale vertices
                         xyz = vec3.fromValues(x[i], y[i], z[i]);
                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
@@ -97 +165 @@
                 
                 //linearize the elements array: 
+                var element;
                 for(var i = 0; i < elements.length; i++){
-                        //convert tris to line edges; generates more edges than necessary, should optimize using node connectivity matlab indices from 1, so decrement indices.
-                        indices.push.apply(indices, [elements[i][0] - 1, elements[i][1] - 1, elements[i][1] - 1, elements[i][2] - 1, elements[i][2] - 1, elements[i][0] - 1]);
+                        element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
+                        if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
+                        indices = indices.concat([element[0], element[1], element[1], element[2], element[2], element[0]]);
                 }
                 indices.itemSize = 1;

issm/trunk-jpl/src/m/plot/plot_overlay.js

@@ -12 +12 @@
         var indices = [];
         var texcoords = [];
+        var nanindices = {};
         var xmin,xmax;
         var ymin,ymax;
@@ -109 +110 @@
         //generate mesh:
         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])) {
+                        nanindices[i] = i;
+                        vertices.push.apply(vertices, vertex);
+                        continue;
+                }
+                //Scale vertices
+                //Scale vertices
                 xyz = vec3.fromValues(x[i], y[i], z[i]);
                 magnitude = vec3.length(xyz);
@@ -118 +127 @@
         }
 
-        //linearize the elements array: 
-        indices = indices.concat.apply(indices, elements); 
+        //linearize the elements array:
+        var element;
+        for(var i = 0; i < elements.length; i++){
+                element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
+                if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
+                indices = indices.concat(element);
+        }
         indices.itemSize = 1;
-        for(var i=0;i<indices.length;i++)indices[i]--; //matlab indices from 1, so decrement.
         
         /*Initalize buffers: */

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

@@ -92 +92 @@
                 var color = edgecolor;
                 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
                         xyz1 = vec3.fromValues(x[i], y[i], z[i]);
                         magnitude = vec3.length(xyz1) + md.geometry.surface[i] * surfacescale;

issm/trunk-jpl/src/m/plot/plot_unit.js

@@ -11 +11 @@
         var indices = [];
         var texcoords = [];
-        var rgbcolor = [];
+        var nanindices = {};
         var xmin,xmax;
         var ymin,ymax;
@@ -23 +23 @@
         var y = meshresults[1]; 
         var z = meshresults[2]; 
-        var elements = meshresults[3]; 
+        var elements = meshresults[3];
         var is2d = meshresults[4]; 
         var isplanet = meshresults[5];
@@ -107 +107 @@
                                 var vertex = vec3.create();
                                 var magnitude;
-        
+
                                 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])) {
+                                                nanindices[i] = i;
+                                                vertices.push.apply(vertices, vertex);
+                                                continue;
+                                        }
+                                        //Scale vertices
                                         xyz = vec3.fromValues(x[i], y[i], z[i]);
                                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
@@ -119 +126 @@
 
                                 //linearize the elements array: 
-                                indices = indices.concat.apply(indices, elements); 
+                                var element;
+                                for(var i = 0; i < elements.length; i++){
+                                        element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
+                                        if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
+                                        indices = indices.concat(element);
+                                }
                                 indices.itemSize = 1;
-                                for(var i=0;i<indices.length;i++)indices[i]--; //matlab indices from 1, so decrement.
 
                         }
@@ -155 +166 @@
 
                                 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])) {
+                                                nanindices[i] = i;
+                                                vertices.push.apply(vertices, vertex);
+                                                continue;
+                                        }
+                                        //Scale vertices
                                         xyz = vec3.fromValues(x[i], y[i], z[i]);
                                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
@@ -190 +208 @@
                                 }
                                 
-                                //linearize the elements array: 
-                                indices = indices.concat.apply(indices, elements); 
+                                //linearize the elements array:
+                                var element;
+                                for(var i = 0; i < elements.length; i++){
+                                        element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
+                                        if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
+                                        indices = indices.concat(element);
+                                }
                                 indices.itemSize = 1;
-                                for(var i=0;i<indices.length;i++)indices[i]--; //matlab indices from 1, so decrement.
                                 
                                 //Initialize movie loop

issm/trunk-jpl/src/m/plot/processmesh.js

@@ -25 +25 @@
 
         if (options.getfieldvalue('coord','xy') !== 'latlon'){
-                x=md.mesh.x;
-                if ('x2d' in md.mesh) x2d=md.mesh.x2d;
-                y=md.mesh.y;
-                if ('y2d' in md.mesh) y2d=md.mesh.y2d;
+                x=md.mesh.x.slice();
+                if ('x2d' in md.mesh) x2d=md.mesh.x2d.slice();
+                y=md.mesh.y.slice();
+                if ('y2d' in md.mesh) y2d=md.mesh.y2d.slice();
         }
         else{
-                x=md.mesh.long;
-                y=md.mesh.lat;
+                x=md.mesh.long.slice();
+                y=md.mesh.lat.slice();
         }
 
         if ('z' in md.mesh){
-                z=md.mesh.z;
+                z=md.mesh.z.slice();
         }
         else{
@@ -45 +45 @@
                 z=md[z];
         }
-
-        if ('elements2d' in md.mesh) elements2d=md.mesh.elements2d;
-        elements=md.mesh.elements;
+        
+        //TODO: Make deep copy of elements array to prevent unwanted modification of model (slice creates deep copies for primitive types, shallow copies for obejcts)
+        if ('elements2d' in md.mesh) elements2d=md.mesh.elements2d.slice();
+        elements=md.mesh.elements.slice();
 
         //is it a 2d plot?