Changeset 19888


Ignore:
Timestamp:
12/13/15 00:11:01 (9 years ago)
Author:
dlcheng
Message:

CHG (javascript): Working implementation of movies for js plots.

Location:
issm/trunk-jpl/src/m/plot
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r19886 r19888  
    5858        node["overlay"] = options.getfieldvalue('overlay','off') == 'on';
    5959        node["drawOrder"] = 0;
    60                
     60                console.log(data,datatype);
    6161        switch(datatype){
    6262
    … …  
    107107                                  patch( 'Faces',[C A D],'Vertices', [x y z],'FaceVertexCData',data(:),'FaceColor','interp','EdgeColor',edgecolor);*/
    108108                        }
    109                         else{ //triangular elements
    110                        
     109                        else{ //triangular elements     
     110                                caxis = options.getfieldvalue('caxis',[ArrayMin(data),ArrayMax(data)]);
     111                                datamin = caxis[0];
     112                                datamax = caxis[1];
     113                                datadelta = datamax - datamin;
     114
    111115                                vertices.itemSize = 3;
    112                                 var cmap=options.getfieldvalue('cmap','jet');
    113                                 //If handling movie data, compute vertices once and texcoords for each movie frame
    114                                 if (data[0] instanceof Float64Array) {
    115                                         for(var i = 0; i < x.length; i++){
    116                                                 vertices[vertices.length] = x[i];
    117                                                 vertices[vertices.length] = y[i];
    118                                                 vertices[vertices.length] = z[i];
    119                                         }       
    120                                         //Transpose data to obtain column addressable data matrix
    121                                         data = data[0].map(function(col, i) {
    122                                                 return data.map(function(row) {
    123                                                         return row[i]
    124                                                 })
    125                                         });
    126                                         for(var i = 0; i < data.length-1; i++){
    127                                                 //Prevent evaluation of datasubarray min/max if caxis exists
    128                                                 if (options.exist('caxis')) {
    129                                                         caxis = options.getfieldvalue('caxis');
    130                                                 }
    131                                                 else {
    132                                                         caxis = [ArrayMin(data[i]),ArrayMax(data[i])];
    133                                                 }
    134                                                 datamin = caxis[0];
    135                                                 datamax = caxis[1];
    136                                                 datadelta = datamax - datamin;
    137                                                
    138                                                 //Precalculate arrays for each datasubarray
    139                                                 texcoords[i] = [];
    140                                                 texcoords[i].itemSize = 2;
    141                                                 for(var j = 0; j < x.length; j++){
    142                                                         texcoords[i][texcoords[i].length] = 0.5;
    143                                                         texcoords[i][texcoords[i].length] = (data[i][j] - datamin) / datadelta;
    144                                                 }
    145                                         }
    146                                        
    147                                         //Initialize movie loop
    148                                         node["movieInterval"] = 1000 / options.getfieldvalue('moviefps',5);
    149                                         node["movieLength"] = data[0].length;
    150                                         node["movieFrame"] = 0;
    151                                         node["movieHandler"] = function () {
    152                                                         node["movieFrame"] = (node["movieFrame"] + 1) % (node["movieLength"]-1);
    153                                                         var array = [node["arrays"][0],node["arrays"][1][node["movieFrame"]],node["arrays"][2]];
    154                                                         node["buffers"] = initBuffers(gl,array);
    155                                                         if (true) {
    156                                                                 setTimeout(node["movieHandler"], node["movieInterval"]);
    157                                                         }
    158                                                 };
    159                                         setTimeout(node["movieHandler"], node["movieInterval"]);
    160                                 }
    161                                 else {
    162                                         caxis = options.getfieldvalue('caxis',[ArrayMin(data),ArrayMax(data)]);
    163                                         datamin = caxis[0];
    164                                         datamax = caxis[1];
    165                                         datadelta = datamax - datamin;
    166                                         texcoords.itemSize = 2;
    167                                         for(var i = 0; i < x.length; i++){
    168                                                 vertices[vertices.length] = x[i];
    169                                                 vertices[vertices.length] = y[i];
    170                                                 vertices[vertices.length] = z[i];
    171 
    172                                                 texcoords[texcoords.length] = 0.5;
    173                                                 texcoords[texcoords.length] = (data[i] - datamin) / datadelta;
    174                                         }
     116                                texcoords.itemSize = 2;
     117                                for(var i = 0; i < x.length; i++){
     118                                        vertices[vertices.length] = x[i];
     119                                        vertices[vertices.length] = y[i];
     120                                        vertices[vertices.length] = z[i];
     121
     122                                        texcoords[texcoords.length] = 0.5;
     123                                        texcoords[texcoords.length] = (data[i] - datamin) / datadelta;
    175124                                }
    176125
    … …  
    181130
    182131                        }
     132                        //Initalize buffers
     133                        node["arrays"] = [vertices, texcoords, indices];
     134                        node["buffers"] = initBuffers(gl,node["arrays"]);
    183135                        break;
    184136                //}}}
    … …  
    192144                                //plot_quiver3(x,y,z,data(:,1),data(:,2),data(:,3),options);
    193145                        }
    194 
    195                 //}}}
     146                        break;
     147                       
     148                //}}}
     149                //node transient plot {{{
     150                case 5:
     151                        if (elements[0].length==6){ //prisms
     152                        }
     153                        else if (elements[0].length==4){//tetras
     154                        }
     155                        else{ //triangular elements
     156                                vertices.itemSize = 3;
     157                                for(var i = 0; i < x.length; i++){
     158                                        vertices[vertices.length] = x[i];
     159                                        vertices[vertices.length] = y[i];
     160                                        vertices[vertices.length] = z[i];
     161                                }       
     162                               
     163                                //Transpose data to obtain column addressable data matrix
     164                                data = data[0].map(function(col, i) {
     165                                        return data.map(function(row) {
     166                                                return row[i]
     167                                        })
     168                                });
     169                               
     170                                for(var i = 0; i < data.length-1; i++){
     171                                        //Prevent evaluation of datasubarray min/max if caxis exists
     172                                        if (options.exist('caxis')) {
     173                                                caxis = options.getfieldvalue('caxis');
     174                                        }
     175                                        else {
     176                                                caxis = [ArrayMin(data[i]),ArrayMax(data[i].slice(0,-1))];
     177                                        }
     178                                        datamin = caxis[0];
     179                                        datamax = caxis[1];
     180                                        datadelta = datamax - datamin;
     181
     182                                        //Precalculate arrays for each datasubarray
     183                                        texcoords[i] = [];
     184                                        texcoords[i].itemSize = 2;
     185                                        for(var j = 0; j < x.length; j++){
     186                                                texcoords[i][texcoords[i].length] = 0.5;
     187                                                texcoords[i][texcoords[i].length] = (data[i][j] - datamin) / datadelta;
     188                                        }
     189                                }
     190                                console.log(texcoords);
     191                               
     192                                //linearize the elements array:
     193                                indices = indices.concat.apply(indices, elements);
     194                                indices.itemSize = 1;
     195                                for(var i=0;i<indices.length;i++)indices[i]--; //matlab indices from 1, so decrement.
     196                               
     197                                //Initialize movie loop
     198                                node["movieInterval"] = 1000 / options.getfieldvalue('moviefps',5);
     199                                node["movieLength"] = data.length-1;
     200                                node["movieFrame"] = 0;
     201                                node["movieHandler"] = function () {
     202                                                node["movieFrame"] = (node["movieFrame"] + 1) % (node["movieLength"]);
     203                                                console.log(node["movieFrame"]);
     204                                                var array = [node["arrays"][0],node["arrays"][1][node["movieFrame"]],node["arrays"][2]];
     205                                                node["buffers"] = initBuffers(gl,array);
     206                                                setTimeout(node["movieHandler"], node["movieInterval"]);
     207                                        };
     208                                setTimeout(node["movieHandler"], node["movieInterval"]);
     209                        }
     210                       
     211                        //Initalize buffers
     212                        node["arrays"] = [vertices, texcoords, indices];
     213                        node["buffers"] = initBuffers(gl,[node["arrays"][0],node["arrays"][1][0],node["arrays"][2]]);
     214                        break;
     215                //}}}
     216                       
    196217                default:
    197218                        throw Error(sprintf("%s%i%s\n",'case ',datatype,' not supported'));
    198219        }
    199        
    200         /*Initalize buffers: */
    201         if (data[0] instanceof Float64Array) {
    202                 node["arrays"] = [vertices, texcoords, indices];
    203                 node["buffers"] = initBuffers(gl,[node["arrays"][0],node["arrays"][1][0],node["arrays"][2]]);
    204         }
    205         else {
    206                 node["arrays"] = [vertices, texcoords, indices];
    207                 node["buffers"] = initBuffers(gl,node["arrays"]);
    208         }
    209220}

  • issm/trunk-jpl/src/m/plot/processdata.js

    r19826 r19888  
    66        //   datatype = 3 -> node quivers
    77        //   datatype = 4 -> patch
     8        //   datatype = 5 -> nodes transient
    89        //
    910        //   Usage:
    … …  
    6061                throw Error('plotmodel error message: data not supported yet');
    6162        }
     63
    6264
    6365        //quiver?
    … …  
    194196                }
    195197        }
     198       
     199        //node transient data
     200    if (datasize==md.mesh.numberofvertices+1){
     201        datatype=5;
     202    }
     203       
    196204
    197205        //layer projection?
Note: See TracChangeset for help on using the changeset viewer.