Ignore:
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:
3 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk

  • issm/trunk/src

  • issm/trunk/src/m/plot/plot_unit.js

    r21729 r22758  
    77        //   See also: PLOTMODEL, PLOT_MANAGER
    88
    9         //{{{ declare variables:
     9        var name = 'unit';
     10        if ('unit' in canvas.nodes) {
     11                if (options.getfieldvalue('clf','on')=='on') {
     12                        for (var node in canvas.nodes) {
     13                                if (node.startsWith('unit')) {
     14                                        delete canvas.octrees[node];
     15                                        delete canvas.nodes[node];
     16                                }
     17                        }
     18                }
     19                else {
     20                        name = 'unit' + Object.keys(canvas.nodes).length;
     21                }
     22        }
     23
     24        //{{{ declare variables:
    1025        //Process data and model
    1126        var meshresults = processmesh(md, data, options);
    … …  
    1631        var is2d = meshresults[4];
    1732        var isplanet = meshresults[5];
     33        if (md.mesh.classname() !== 'mesh3dsurface') z = md.geometry.surface;
    1834       
    19         var vertices = new Float32Array(x.length * 3);
    20         var texcoords = new Float32Array(x.length * 2);
    21         var indices = new Uint16Array(elements.length * 3);
    22         var nanindices = {};
    23         var xmin, xmax;
    24         var ymin, ymax;
    25         var zmin, zmax;
    26         var datamin, datamax, datadelta;
    27         var matrixscale, vertexscale;
    28         //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
    29         if (!md.geometry.surface) {
    30                 md.geometry.surface=NewArrayFill(md.mesh.x.length, 0);
    31         }
    32         if (md.mesh.classname() == 'mesh3dsurface') {
    33                 matrixscale = 1;
    34                 vertexscale = options.getfieldvalue('heightscale', 1);
     35        //Compute coordinates and data range:
     36        var xlim = options.getfieldvalue('xlim', [ArrayMin(x), ArrayMax(x)]);
     37        var ylim = options.getfieldvalue('ylim', [ArrayMin(y), ArrayMax(y)]);
     38        var zlim = options.getfieldvalue('zlim', [ArrayMin(z), ArrayMax(z)]);
     39       
     40        //Handle heightscale
     41        var vertices, scale;
     42        if (md.mesh.classname() !== 'mesh3dsurface') {
     43                vertices = [x, y, z];
     44                scale = [1, 1, options.getfieldvalue('heightscale', 1)];
    3545        }
    3646        else {
    37                 if (md.geometry.surface) {
    38                         z=md.geometry.surface;
    39                 }       
    40                 matrixscale = options.getfieldvalue('heightscale', 1);
    41                 vertexscale = 0;
     47                vertices = Node.prototype.scaleVertices(md, x, y, z, elements, options.getfieldvalue('heightscale', 1), options.getfieldvalue('maskregion',{'enabled':false}));
     48                scale = [1, 1, 1];
     49        }
     50       
     51        //Compute gl variables:
     52        var edgecolor = options.getfieldvalue('edgecolor', [1.0, 1.0, 1.0 ,1.0]);
     53        var maskzeros = options.getfieldvalue('maskzeros', {});
     54        var render = options.getfieldvalue('render', {});
     55        var cullFace = ("unit" in render) ? canvas.gl[render.unit.cullFace] : canvas.gl.BACK;
     56        var node = new Node(
     57                'canvas', canvas,
     58                'options', options,
     59                'name', name,
     60                'shaderName', 'TexturedDiffuse',
     61                'alpha', options.getfieldvalue('alpha', 1.0),
     62                'caxis', options.getfieldvalue('caxis',[ArrayMin(data), ArrayMax(data)]),
     63                'center', [(xlim[0] + xlim[1]) / 2, (ylim[0] + ylim[1]) / 2, (zlim[0] + zlim[1]) / 2],
     64                'cullFace', cullFace,
     65                'lightingBias', canvas.view.lightingBias,
     66                'diffuseColor', edgecolor,
     67                'specularStrength', 0.0,
     68                'enabled', options.getfieldvalue('nodata','off') == 'off' || (("unit" in render) && render.unit.enabled),
     69                'log', options.getfieldvalue('log',false),
     70                'maskEnabled', options.getfieldvalue('innermask','off') == 'on',
     71                'maskHeight', options.getfieldvalue('innermaskheight', 150.0) / options.getfieldvalue('heightscale', 1),
     72                'maskColor', options.getfieldvalue('innermaskcolor',[0.0, 0.0, 1.0, 1.0]),
     73                'maskObject', options.getfieldvalue('maskregion',{'enabled':false}),
     74                'maskZerosColor', defaultFor(maskzeros.color,[1.0, 1.0, 1.0, 1.0]),
     75                'maskZerosEnabled', defaultFor(maskzeros.enabled,false),
     76                'maskZerosTolerance', defaultFor(maskzeros.tolerance,1e-3),
     77                'maskZerosZeroValue', defaultFor(maskzeros.zeroValue,0.5),
     78                'rotation', [-90, 0, 0],
     79                'scale', ("unit" in render) ? [render.unit.scale, render.unit.scale, render.unit.scale] : scale
     80        );
     81        //}
     82        if (options.getfieldvalue('clf','on')=='on') {
     83                canvas.unitNode = node;
     84                canvas.unitData = data;
    4285        }
    4386        //}}}
    44 
    45         //Compute coordinates and data range:
    46         var modelxlim = [ArrayMin(x), ArrayMax(x)];
    47         var modelylim = [ArrayMin(y), ArrayMax(y)];
    48         var modelzlim = [ArrayMin(z), ArrayMax(z)];
    49         var xlim = options.getfieldvalue('xlim', modelxlim);
    50         var ylim = options.getfieldvalue('ylim', modelylim);
    51         var zlim = options.getfieldvalue('zlim', modelzlim);
    52         xmin = xlim[0];
    53         xmax = xlim[1];
    54         ymin = ylim[0];
    55         ymax = ylim[1];
    56         zmin = zlim[0];
    57         zmax = zlim[1];
    58         var caxis;
    59 
    60         //Compute gl variables:
    61         var gl = canvas.gl;
    62         var node = Node(gl);
    63         canvas.nodes[canvas.nodes.length] = node;
    64         canvas.unitNode = node;
    65         canvas.unitData = data;
    66         node.name = "unit";
    67         node.shaderName = "Textured";
    68         node.shader = gl.shaders[node.shaderName];
    69         node.scale = [1, 1, matrixscale];
    70         node.rotation = [-90, 0, 0];
    71         node.translation = [0, 0, 0];
    72         node.center = [(xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2];
    73         node.alpha = options.getfieldvalue('alpha', 1.0);
    74         node.drawOrder = 1;
    75         node.maskEnabled = options.getfieldvalue('innermask','off') == 'on';
    76         node.maskHeight = options.getfieldvalue('innermaskheight', 150.0);
    77         node.maskColor = options.getfieldvalue('innermaskcolor',[0.0, 0.0, 1.0, 1.0]);
    78         node.enabled = options.getfieldvalue('nodata','off') == 'off';
    79         updateModelMatrix(node);
    80 
    8187        switch(datatype){
    8288                //{{{ element plot
    8389                case 1:
     90                        //WARNING: NaN are not properly found (NaN != NaN = true)
    8491                        pos=ArrayFindNot(data, NaN); //needed for element on water
    8592                        if (elements[0].length==6){ //prisms
    … …  
    8794                        else if (elements[0].length==4){ //tetras
    8895                        }
    89                         else{ //2D triangular elements
     96                        else{ //triangular elements
     97                                node.patch('Faces', elements, 'Vertices', vertices, 'FaceVertexCData', data, 'FaceColor', 'flat', 'EdgeColor', edgecolor);
    9098                        }
    9199                        break;
    … …  
    98106                        }
    99107                        else{ //triangular elements     
    100                                 caxis = options.getfieldvalue('caxis',[ArrayMin(data), ArrayMax(data)]);
    101                                 if (options.getfieldvalue('log','off')!='off') caxis = [Math.log10(caxis[0])/Math.log10(options.getfieldvalue('log', 10)), Math.log10(caxis[1])/Math.log10(options.getfieldvalue('log', 10))];
    102                                 datamin = caxis[0];
    103                                 datamax = caxis[1];
    104                                 datadelta = datamax - datamin;
    105 
    106                                 var xyz = vec3.create();
    107                                 var direction = vec3.create();
    108                                 var vertex = vec3.create();
    109                                 var magnitude;
    110 
    111                                 for(var i = 0, vindex = 0, tindex = 0; i < x.length; i++){
    112                                         //Check for NaN values and remove from indices array as necessary, but preserve vertex array spacing
    113                                         if (isNaN(x[i]) || isNaN(y[i]) || isNaN(z[i]) || isNaN(data[i])) {
    114                                                 nanindices[i] = i;
    115                                                 vertices[vindex++] = vertex[0];
    116                                                 vertices[vindex++] = vertex[1];
    117                                                 vertices[vindex++] = vertex[2];
    118                                                
    119                                                 texcoords[tindex++] = 0.5;
    120                                                 texcoords[tindex++] = 0.0;
    121                                                 continue;
    122                                         }
    123 
    124                                         //Scale vertices
    125                                         xyz = vec3.fromValues(x[i], y[i], z[i]);
    126                                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
    127                                         vec3.normalize(direction, xyz);
    128                                         vec3.scale(vertex, direction, magnitude);
    129                                         vertices[vindex++] = vertex[0];
    130                                         vertices[vindex++] = vertex[1];
    131                                         vertices[vindex++] = vertex[2];
    132 
    133                                         texcoords[tindex++] = 0.5;
    134                                         texcoords[tindex++] = clamp((data[i] - datamin) / datadelta, 0.0, 1.0);
    135                                 }
    136 
    137                                 //linearize the elements array:
    138                                 var element;
    139                                 for(var i = 0, iindex = 0; i < elements.length; i++){
    140                                         element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
    141                                         if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
    142                                         indices[iindex++] = element[0];
    143                                         indices[iindex++] = element[1];
    144                                         indices[iindex++] = element[2];
    145                                 }
     108                                node.patch('Faces', elements, 'Vertices', vertices, 'FaceVertexCData', data, 'FaceColor', 'interp', 'EdgeColor', edgecolor);
    146109                        }
    147                         node.mesh = GL.Mesh.load({vertices: vertices, coords: texcoords, triangles: indices}, null, null, gl);
    148                         node.mesh.octree = new GL.Octree(node.mesh);
    149110                        break;
    150111                //}}}
    … …  
    159120                        break;
    160121                //}}}
    161                 //{{{ node transient plot
    162                 case 5:
    163                         if (elements[0].length==6){ //prisms
    164                         }
    165                         else if (elements[0].length==4){//tetras
    166                         }
    167                         else{ //triangular elements
    168                                 var xyz = vec3.create();
    169                                 var direction = vec3.create();
    170                                 var vertex = vec3.create();
    171                                 var magnitude;
    172                                 var timestamps = data[data.length-1];
    173                                 for(var i = 0, vindex = 0, tindex = 0; i < x.length; i++){
    174                                         //Check for NaN values and remove from indices array as necessary, but preserve vertex array spacing
    175                                         if (isNaN(x[i]) || isNaN(y[i]) || isNaN(z[i]) || isNaN(data[i][0])) {
    176                                                 nanindices[i] = i;
    177                                         }
    178                                         else {
    179                                                 //Scale vertices
    180                                                 xyz = vec3.fromValues(x[i], y[i], z[i]);
    181                                                 magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
    182                                                 vec3.normalize(direction, xyz);
    183                                                 vec3.scale(vertex, direction, magnitude);
    184                                         }
    185                                         vertices[vindex++] = vertex[0];
    186                                         vertices[vindex++] = vertex[1];
    187                                         vertices[vindex++] = vertex[2];
    188                                 }       
    189                                 //Transpose data to obtain column addressable data matrix
    190                                 data = data[0].map(function(col, i) {
    191                                         return data.map(function(row) {
    192                                                 return row[i]
    193                                         })
    194                                 });
    195                                 //Prevent evaluation of datasubarray min/max if caxis exists
    196                                 if (options.exist('caxis')) caxis = options.getfieldvalue('caxis');
    197                                 else caxis = [ArrayMin(data[0]), ArrayMax(data[0].slice(0,-1))];
    198                                 if (options.getfieldvalue('log','off')!='off') caxis = [Math.log10(caxis[0])/Math.log10(options.getfieldvalue('log', 10)), Math.log10(caxis[1])/Math.log10(options.getfieldvalue('log', 10))];
    199                                 //Prepare texcoords to hold array of data values
    200                                 texcoords = [];
    201                                 for(var i = 0; i < data.length; i++){                                   
    202                                         datamin = caxis[0];
    203                                         datamax = caxis[1];
    204                                         datadelta = datamax - datamin;
    205                                         //Precalculate arrays for each datasubarray, trimming off timestamp value by using x.length instead of data[i].length
    206                                         texcoords[i] = new Float32Array(x.length * 2);
    207                                         for(var j = 0, index = 0; j < x.length; j++){
    208                                                 texcoords[i][index++] = 0.5;
    209                                                 texcoords[i][index++] = clamp((data[i][j] - datamin) / datadelta, 0.0, 1.0);
    210                                         }
    211                                 }
    212                                
    213                                 //linearize the elements array:
    214                                 var element;
    215                                 for(var i = 0, iindex = 0; i < elements.length; i++){
    216                                         element = [elements[i][0] - 1, elements[i][1] - 1, elements[i][2] - 1];
    217                                         if (element[0] in nanindices || element[1] in nanindices || element[2] in nanindices) continue;
    218                                         indices[iindex++] = element[0];
    219                                         indices[iindex++] = element[1];
    220                                         indices[iindex++] = element[2];
    221                                 }
    222                        
    223                                 //Initialize movie loop
    224                                 node.movieLoop = canvas.animation.loop;
    225                                 node.movieInterval = 1000 / canvas.animation.fps;
    226                                 node.movieTimestamps = timestamps;
    227                                 node.movieLength = timestamps.length;
    228                                 node.movieFrame = 0;
    229                                 canvas.dataMarkers.values = [];
    230                                 var quiverVelFrames = {};
    231                                 for(var i=0; i < md.results.length; i++){
    232                                         quiverVelFrames[Math.floor(md.results[i].time)] = md.results[i];
    233                                 }
    234 
    235                                 if (canvas.animation.handler !== 0) {
    236                                         console.log("clearing...");
    237                                         clearInterval(canvas.animation.handler)
    238                                 }
    239                                 //TODO: Move this into webgl.js
    240                                 canvas.animation.handler = setInterval(function () {
    241                                         node.movieFrame = canvas.animation.frame;
    242                                         if (canvas.animation.play && canvas.animation.increment) {
    243                                                 if (node.movieFrame == node.movieLength - 1) {
    244                                                         if (node.movieLoop) {
    245                                                                 node.movieFrame = 0;
    246                                                         }
    247                                                         else {
    248                                                                 toggleMoviePlay(canvas);
    249                                                         }
    250                                                 }
    251                                                 else {
    252                                                         node.movieFrame = node.movieFrame + 1;
    253                                                 }
    254                                                 if (canvas.animation.lastFrame != canvas.animation.frame) {
    255                                                         updateMarker(canvas, false);
    256                                                 }
    257                                         }
    258                                        
    259                                         if (canvas.progressBar) {
    260                                                 canvas.progressBar.val(node.movieFrame);
    261                                                 canvas.progressBar.slider('refresh');
    262                                         }
    263                                         if (canvas.timeLabel) { canvas.timeLabel.html(node.movieTimestamps[node.movieFrame].toFixed(0) + " " + options.getfieldvalue("movietimeunit","yr")); }
    264                                        
    265                                         var buffer = node.mesh.getBuffer("coords");
    266                                         buffer.data = texcoords[node.movieFrame];
    267                                         buffer.upload(canvas.gl.DYNAMIC_DRAW);
    268                                         node.mesh.octree = new GL.Octree(node.mesh);
    269                                         node.texcoords = texcoords;
    270                                         if(options.getfieldvalue('quiver') == 'on'){
    271                                                 plot_quiver(md, options, canvas, {vel: quiverVelFrames[node.movieFrame].Vel, vx: quiverVelFrames[node.movieFrame].Vx, vy: quiverVelFrames[node.movieFrame].Vy});
    272                                         }
    273                                         canvas.animation.lastFrame = canvas.animation.frame;
    274                                         canvas.animation.frame = node.movieFrame;                                       
    275                                 }, node.movieInterval);
    276                                
    277                                 if (canvas.progressBar) {
    278                                         canvas.animation.frame = 0;
    279                                         canvas.progressBar.val(0);
    280                                         canvas.progressBar.attr('max', node.movieLength-1);
    281                                         canvas.progressBar.slider('refresh');
    282                                 }
    283                                
    284                         }
    285                         node.mesh = GL.Mesh.load({vertices: vertices, coords: texcoords[0], triangles: indices}, null, null, gl);
    286                         node.mesh.octree = new GL.Octree(node.mesh);
    287                         break;
    288                 //}}}
    289122                default:
    290                         throw Error(sprintf("%s%i%s\n",'case ', datatype,' not supported'));
     123                        throw Error(sprintf('%s%i%s\n','case ', datatype,' not supported'));
    291124        }
    292125} //}}}
Note: See TracChangeset for help on using the changeset viewer.