Changeset 20234


Ignore:
Timestamp:
02/24/16 12:30:21 (9 years ago)
Author:
dlcheng
Message:

CHG (javascript): Dynamic height scaling for 3d/2d meshes

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

Legend:

Unmodified
Added
Removed

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

    r20208 r20234  
    1313        var ymin,ymax;
    1414        var zmin,zmax;
    15         var scale;
     15        var scale,zscale,surfacescale;
    1616       
    1717        //Process data and model
    … …  
    2323        var is2d = meshresults[4];
    2424        var isplanet = meshresults[5];
    25         var is3d = md.mesh.classname() == 'mesh3dsurface'; //use meshresults once behvaior can be verified
    26        
    27         if (!is3d && md.geometry.surface) {
    28                 z = md.geometry.surface;
     25               
     26        if (!md.geometry.surface) {
     27                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
     28        }
     29        if (md.mesh.classname() == 'mesh3dsurface') {
     30                zscale = 1;
     31                surfacescale = options.getfieldvalue('heightscale',1);
     32        }
     33        else {
     34                if (md.geometry.surface) {
     35                        z=md.geometry.surface;
     36                }       
     37                zscale = options.getfieldvalue('heightscale',1);
     38                surfacescale = 0;
    2939        }
    3040        //}}}
    … …  
    4858        node["shaderName"] = "colored";
    4959        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    50         node["scale"] = [scale, scale, scale*options.getfieldvalue('heightscale',1)];
     60        node["scale"] = [scale, scale, scale * zscale];
    5161        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    5262        node["modelMatrix"] = recalculateModelMatrix(node);
    … …  
    7282        else{ //2D triangular elements
    7383                vertices.itemSize = 3;
     84                var xyz = vec3.create();
     85                var direction = vec3.create();
     86                var vertex = vec3.create();
     87                var magnitude;
     88                var color = [0.0, 0.0, 0.0, 1.0];
    7489                for(var i = 0; i < x.length; i++){
    75                         vertices[vertices.length] = x[i];
    76                         vertices[vertices.length] = y[i];
    77                         vertices[vertices.length] = z[i];
     90                        xyz = vec3.fromValues(x[i], y[i], z[i]);
     91                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     92                        vec3.normalize(direction, xyz);
     93                        vec3.scale(vertex, direction, magnitude);
     94                        vertices.push.apply(vertices, vertex);
    7895
    79                         rgbcolor = [0.0, 0.0, 0.0];
    80                         colors[colors.length] = rgbcolor[0];
    81                         colors[colors.length] = rgbcolor[1];
    82                         colors[colors.length] = rgbcolor[2];
    83                         colors[colors.length] = 1.0;
     96                        colors.push.apply(colors, color);
    8497                }
    85 
     98               
    8699                //linearize the elements array:
    87100                for(var i = 0; i < elements.length; i++){
    88                         //convert tris to line edges; generates more edges than necessary, should optimize using node connectivity
    89                         //matlab indices from 1, so decrement indices.
    90                         indices[indices.length] = elements[i][0] - 1;
    91                         indices[indices.length] = elements[i][1] - 1;
    92                         indices[indices.length] = elements[i][1] - 1;
    93                         indices[indices.length] = elements[i][2] - 1;
    94                         indices[indices.length] = elements[i][2] - 1;
    95                         indices[indices.length] = elements[i][0] - 1;
     101                        //convert tris to line edges; generates more edges than necessary, should optimize using node connectivity matlab indices from 1, so decrement indices.
     102                        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]);
    96103                }
    97104                indices.itemSize = 1;

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

    r20208 r20234  
    1515        var ymin,ymax;
    1616        var zmin,zmax;
     17        var scale,zscale,surfacescale;
    1718
    1819        //Process data and model
    … …  
    2425        var is2d = meshresults[4];
    2526        var isplanet = meshresults[5];
    26         var is3d = (md.mesh.classname() == 'mesh3dsurface'); //use meshresults once behvaior can be verified
    27        
    28         if (!is3d && md.geometry.surface) {
    29                 z = md.geometry.surface;
     27
     28        if (!md.geometry.surface) {
     29                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
     30        }
     31        if (md.mesh.classname() == 'mesh3dsurface') {
     32                zscale = 1;
     33                surfacescale = options.getfieldvalue('heightscale',1);
     34        }
     35        else {
     36                if (md.geometry.surface) {
     37                        z=md.geometry.surface;
     38                }       
     39                zscale = options.getfieldvalue('heightscale',1);
     40                surfacescale = 0;
    3041        }
    3142        //}}}
    … …  
    4657               
    4758        //Compute scaling:
    48         var scale = 1 / (xmax - xmin);
     59        scale = 1 / (xmax - xmin);
    4960        node["shaderName"] = "unlit_textured";
    5061        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    51         node["scale"] = [scale, scale, scale*options.getfieldvalue('heightscale',1)];
     62        node["scale"] = [scale, scale, scale * zscale];
    5263        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    5364        node["modelMatrix"] = recalculateModelMatrix(node);
    … …  
    91102        var xrange = modelxlim[1] - modelxlim[0];
    92103        var yrange = modelylim[1] - modelylim[0];
     104       
     105        var xyz = vec3.create();
     106        var direction = vec3.create();
     107        var vertex = vec3.create();
     108        var magnitude;
    93109
    94110        //generate mesh:
     111        console.log(md);
    95112        for(var i = 0; i < x.length; i++){
    96                 vertices[vertices.length] = x[i];
    97                 vertices[vertices.length] = y[i];
    98                 vertices[vertices.length] = z[i];
     113                xyz = vec3.fromValues(x[i], y[i], z[i]);
     114                magnitude = vec3.length(xyz);
     115                vec3.normalize(direction, xyz);
     116                vec3.scale(vertex, direction, magnitude);
     117                vertices.push.apply(vertices, vertex);
    99118
    100                 texcoords[texcoords.length] = (x[i] - modelxlim[0]) / xrange;
    101                 texcoords[texcoords.length] = (y[i] - modelylim[0]) / yrange;
     119                texcoords.push.apply(texcoords, [(x[i] - modelxlim[0]) / xrange, (y[i] - modelylim[0]) / yrange]);
    102120        }
    103121

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

    r20208 r20234  
    1616        var zmin,zmax;
    1717        var datamin,datamax,datadelta;
    18         var scale;
     18        var scale,zscale,surfacescale;
    1919
    2020        //Process data and model
    … …  
    2626        var is2d = meshresults[4];
    2727        var isplanet = meshresults[5];
    28         var is3d = md.mesh.classname() == 'mesh3dsurface'; //use meshresults once behvaior can be verified
    2928       
    3029        var     dataresults = processdata(md,data,options);
    3130        var     data2 = dataresults[0];
    3231        var     datatype = dataresults[1];
    33        
    34         if (!is3d && md.geometry.surface) {
    35                 z = md.geometry.surface;
     32
     33        if (!md.geometry.surface) {
     34                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
     35        }
     36        if (md.mesh.classname() == 'mesh3dsurface') {
     37                zscale = 1;
     38                surfacescale = options.getfieldvalue('heightscale',1);
     39        }
     40        else {
     41                if (md.geometry.surface) {
     42                        z=md.geometry.surface;
     43                }       
     44                zscale = options.getfieldvalue('heightscale',1);
     45                surfacescale = 0;
    3646        }
    3747        //}}}
    … …  
    5161        zmax = zlim[1];
    5262        var caxis;
    53 
     63       
    5464        //Compute scaling:
    55         var scale = 1 / (xmax - xmin);
     65        scale = 1 / (xmax - xmin);
    5666        node["shaderName"] = "unlit_textured";
    5767        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    58         node["scale"] = [scale, scale, scale*options.getfieldvalue('heightscale',1)];
     68        node["scale"] = [scale, scale, scale * zscale];
    5969        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    6070        node["modelMatrix"] = recalculateModelMatrix(node);
    … …  
    93103                                vertices.itemSize = 3;
    94104                                texcoords.itemSize = 2;
    95                                 //var height = vec3.create();
    96                                 //var heightscale = options.getfieldvalue('heightscale',1);
     105                               
     106                                var xyz = vec3.create();
     107                                var direction = vec3.create();
     108                                var vertex = vec3.create();
     109                                var magnitude;
     110       
    97111                                for(var i = 0; i < x.length; i++){
    98                                         //vec3.normalize(height, vec3.fromValues(x[i], y[i], z[i])); //fix to use normalized earth radius instead of radius+ height
    99                                         //vec3.scale(height, height, heightscale);
    100                                         vertices[vertices.length] = x[i];
    101                                         vertices[vertices.length] = y[i];
    102                                         vertices[vertices.length] = z[i];
    103 
    104                                         texcoords[texcoords.length] = 0.5;
    105                                         texcoords[texcoords.length] = (data[i] - datamin) / datadelta;
     112                                        xyz = vec3.fromValues(x[i], y[i], z[i]);
     113                                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     114                                        vec3.normalize(direction, xyz);
     115                                        vec3.scale(vertex, direction, magnitude);
     116                                        vertices.push.apply(vertices, vertex);
     117
     118                                        texcoords.push.apply(texcoords, [0.5, (data[i] - datamin) / datadelta]);
    106119                                }
    107120
    … …  
    135148                        else{ //triangular elements
    136149                                vertices.itemSize = 3;
     150                               
     151                                var xyz = vec3.create();
     152                                var direction = vec3.create();
     153                                var vertex = vec3.create();
     154                                var magnitude;
     155
    137156                                for(var i = 0; i < x.length; i++){
    138                                         vertices[vertices.length] = x[i];
    139                                         vertices[vertices.length] = y[i];
    140                                         vertices[vertices.length] = z[i];
     157                                        xyz = vec3.fromValues(x[i], y[i], z[i]);
     158                                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     159                                        vec3.normalize(direction, xyz);
     160                                        vec3.scale(vertex, direction, magnitude);
     161                                        vertices.push.apply(vertices, vertex);
    141162                                }       
    142163                               
    … …  
    164185                                        texcoords[i].itemSize = 2;
    165186                                        for(var j = 0; j < x.length; j++){
    166                                                 texcoords[i][texcoords[i].length] = 0.5;
    167                                                 texcoords[i][texcoords[i].length] = (data[i][j] - datamin) / datadelta;
     187                                                texcoords.push.apply(texcoords, [0.5, (data[i][j] - datamin) / datadelta]);
    168188                                        }
    169189                                }
Note: See TracChangeset for help on using the changeset viewer.