source: issm/oecreview/Archive/20545-21336/ISSM-20564-20565.diff@ 21337

Last change on this file since 21337 was 21337, checked in by Mathieu Morlighem, 8 years ago

CHG: added Archive/20545-21336

File size: 9.7 KB

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

     
    1515        var ymin,ymax;
    1616        var zmin,zmax;
    1717        var datamin,datamax,datadelta;
    18         var scale,zscale,surfacescale;
     18        var scale,matrixscale,vertexscale;
    1919
    2020        //Process data and model
    2121        var meshresults = processmesh(md,data,options);
    … …  
    3030        var     data2 = dataresults[0];
    3131        var     datatype = dataresults[1];
    3232
     33        //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
    3334        if (!md.geometry.surface) {
    3435                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
    3536        }
    3637        if (md.mesh.classname() == 'mesh3dsurface') {
    37                 zscale = 1;
    38                 surfacescale = options.getfieldvalue('heightscale',1);
     38                matrixscale = 1;
     39                vertexscale = options.getfieldvalue('heightscale',1);
    3940        }
    4041        else {
    4142                if (md.geometry.surface) {
    4243                        z=md.geometry.surface;
    4344                }       
    44                 zscale = options.getfieldvalue('heightscale',1);
    45                 surfacescale = 0;
     45                matrixscale = options.getfieldvalue('heightscale',1);
     46                vertexscale = 0;
    4647        }
    4748        //}}}
    4849
    … …  
    6162        zmax = zlim[1];
    6263        var caxis;
    6364       
    64         //Compute scaling:
     65        //Compute gl variables:
    6566        scale = 1 / (xmax - xmin);
    6667        node["shaderName"] = "unlit_textured";
    6768        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    68         node["scale"] = [scale, scale, scale * zscale];
     69        node["scale"] = [scale, scale, scale * matrixscale];
    6970        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    7071        node["modelMatrix"] = recalculateModelMatrix(node);
    7172        node["alpha"] = options.getfieldvalue('alpha',1.0);
    … …  
    119120                                        }
    120121                                        //Scale vertices
    121122                                        xyz = vec3.fromValues(x[i], y[i], z[i]);
    122                                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     123                                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
    123124                                        vec3.normalize(direction, xyz);
    124125                                        vec3.scale(vertex, direction, magnitude);
    125126                                        vertices[vertices.length] = vertex[0];
    … …  
    182183                                        }
    183184                                        //Scale vertices
    184185                                        xyz = vec3.fromValues(x[i], y[i], z[i]);
    185                                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     186                                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
    186187                                        vec3.normalize(direction, xyz);
    187188                                        vec3.scale(vertex, direction, magnitude);
    188189                                        vertices[vertices.length] = vertex[0];

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

     
    1313        var xmin,xmax;
    1414        var ymin,ymax;
    1515        var zmin,zmax;
    16         var scale,zscale,surfacescale;
     16        var scale,matrixscale,vertexscale;
    1717       
    1818        //Process data and model
    1919        var meshresults = processmesh(md,[],options);
    … …  
    2626        var vx = md.initialization.vx;
    2727        var vy = md.initialization.vy;
    2828               
     29        //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
    2930        if (!md.geometry.surface) {
    3031                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
    3132        }
    3233        if (md.mesh.classname() == 'mesh3dsurface') {
    33                 zscale = 1;
    34                 surfacescale = options.getfieldvalue('heightscale',1);
     34                matrixscale = 1;
     35                vertexscale = options.getfieldvalue('heightscale',1);
    3536        }
    3637        else {
    3738                if (md.geometry.surface) {
    3839                        z=md.geometry.surface;
    3940                }       
    40                 zscale = options.getfieldvalue('heightscale',1);
    41                 surfacescale = 0;
     41                matrixscale = options.getfieldvalue('heightscale',1);
     42                vertexscale = 0;
    4243        }
    4344        //}}}
    4445
    … …  
    5657        zmin = zlim[0];
    5758        zmax = zlim[1];
    5859
    59         //Compute scaling:
     60        //Compute gl variables:
    6061        var scale = 1 / (xmax - xmin);
    6162        node["shaderName"] = "colored";
    6263        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    63         node["scale"] = [scale, scale, scale * zscale];
     64        node["scale"] = [scale, scale, scale * matrixscale];
    6465        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    6566        node["modelMatrix"] = recalculateModelMatrix(node);
    6667        node["drawMode"] = gl.LINES;
    … …  
    9596                        if (isNaN(x[i]) || isNaN(y[i]) || isNaN(z[i])) continue;
    9697                        //Scale vertices
    9798                        xyz1 = vec3.fromValues(x[i], y[i], z[i]);
    98                         magnitude = vec3.length(xyz1) + md.geometry.surface[i] * surfacescale;
     99                        magnitude = vec3.length(xyz1) + md.geometry.surface[i] * vertexscale;
    99100                        vec3.normalize(direction, xyz1);
    100101                        vec3.scale(vertex, direction, magnitude);
    101102                        vertices[vertices.length] = vertex[0];

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

     
    1515        var xmin,xmax;
    1616        var ymin,ymax;
    1717        var zmin,zmax;
    18         var scale,zscale,surfacescale;
     18        var scale,matrixscale,vertexscale;
    1919
    2020        //Process data and model
    2121        var meshresults = processmesh(md,data,options);
    … …  
    2626        var is2d = meshresults[4];
    2727        var isplanet = meshresults[5];
    2828
     29        //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
    2930        if (!md.geometry.surface) {
    3031                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
    3132        }
    3233        if (md.mesh.classname() == 'mesh3dsurface') {
    33                 zscale = 1;
    34                 surfacescale = options.getfieldvalue('heightscale',1);
     34                matrixscale = 1;
     35                vertexscale = options.getfieldvalue('heightscale',1);
    3536        }
    3637        else {
    3738                if (md.geometry.surface) {
    3839                        z=md.geometry.surface;
    3940                }       
    40                 zscale = options.getfieldvalue('heightscale',1);
    41                 surfacescale = 0;
     41                matrixscale = options.getfieldvalue('heightscale',1);
     42                vertexscale = 0;
    4243        }
    4344        //}}}
    4445       
    … …  
    5657        zmin = zlim[0];
    5758        zmax = zlim[1];
    5859               
    59         //Compute scaling:
     60        //Compute gl variables:
    6061        scale = 1 / (xmax - xmin);
    6162        node["shaderName"] = "unlit_textured";
    6263        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    63         node["scale"] = [scale, scale, scale * zscale];
     64        node["scale"] = [scale, scale, scale * matrixscale];
    6465        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    6566        node["modelMatrix"] = recalculateModelMatrix(node);
    6667        node["texture"] = initTexture(gl,options.getfieldvalue('image'));
    … …  
    117118                        vertices[vertices.length] = vertex[2];
    118119                        continue;
    119120                }
    120                 //Scale vertices
    121                 xyz = vec3.fromValues(x[i], y[i], z[i]);
    122                 magnitude = vec3.length(xyz);
    123                 vec3.normalize(direction, xyz);
    124                 vec3.scale(vertex, direction, magnitude);
    125                 vertices[vertices.length] = vertex[0];
    126                 vertices[vertices.length] = vertex[1];
    127                 vertices[vertices.length] = vertex[2];
    128                
     121
    129122                if (md.mesh.classname() == 'mesh3dsurface') {
    130                         texcoords[texcoords.length] = degrees(Math.atan2(y[i], x[i])) / 360 + 0.5;
    131                         texcoords[texcoords.length] = degrees(Math.asin(z[i] / magnitude)) / 180 + 0.5;
     123                        //Scale vertices
     124                        xyz = vec3.fromValues(x[i], y[i], z[i]);
     125                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
     126                        vec3.normalize(direction, xyz);
     127                        vec3.scale(vertex, direction, magnitude);
     128                        vertices[vertices.length] = vertex[0];
     129                        vertices[vertices.length] = vertex[1];
     130                        vertices[vertices.length] = vertex[2];
     131                       
     132                        texcoords[texcoords.length] = degrees(Math.atan2(vertex[1], vertex[0])) / 360 + 0.5;
     133                        texcoords[texcoords.length] = degrees(Math.asin(vertex[2] / magnitude)) / 180 + 0.5;
    132134                }
    133135                else {
     136                        //Scale vertices
     137                        xyz = vec3.fromValues(x[i], y[i], z[i]);
     138                        magnitude = vec3.length(xyz);
     139                        vec3.normalize(direction, xyz);
     140                        vec3.scale(vertex, direction, magnitude);
     141                        vertices[vertices.length] = vertex[0];
     142                        vertices[vertices.length] = vertex[1];
     143                        vertices[vertices.length] = vertex[2];
     144                       
    134145                        texcoords[texcoords.length] = (x[i] - modelxlim[0]) / xrange;
    135146                        texcoords[texcoords.length] = (y[i] - modelylim[0]) / yrange;
    136147                }

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

     
    1212        var xmin,xmax;
    1313        var ymin,ymax;
    1414        var zmin,zmax;
    15         var scale,zscale,surfacescale;
     15        var scale,matrixscale,vertexscale;
    1616       
    1717        //Process data and model
    1818        var meshresults = processmesh(md,[],options);
    … …  
    2323        var is2d = meshresults[4];
    2424        var isplanet = meshresults[5];
    2525               
     26        //Compue scaling through matrices for 2d meshes and vertices for 3d meshes
    2627        if (!md.geometry.surface) {
    2728                md.geometry.surface=NewArrayFill(md.mesh.x.length,0);
    2829        }
    2930        if (md.mesh.classname() == 'mesh3dsurface') {
    30                 zscale = 1;
    31                 surfacescale = options.getfieldvalue('heightscale',1);
     31                matrixscale = 1;
     32                vertexscale = options.getfieldvalue('heightscale',1);
    3233        }
    3334        else {
    3435                if (md.geometry.surface) {
    3536                        z=md.geometry.surface;
    3637                }       
    37                 zscale = options.getfieldvalue('heightscale',1);
    38                 surfacescale = 0;
     38                matrixscale = options.getfieldvalue('heightscale',1);
     39                vertexscale = 0;
    3940        }
    4041        //}}}
    4142
    … …  
    5354        zmin = zlim[0];
    5455        zmax = zlim[1];
    5556
    56         //Compute scaling:
     57        //Compute gl variables:
    5758        var scale = 1 / (xmax - xmin);
    5859        node["shaderName"] = "colored";
    5960        node["shader"] = gl["shaders"][node["shaderName"]]["program"];
    60         node["scale"] = [scale, scale, scale * zscale];
     61        node["scale"] = [scale, scale, scale * matrixscale];
    6162        node["translation"] = [(xmin + xmax) / (-2 / scale), (ymin + ymax) / (-2 / scale), (zmin + zmax) / (2 / scale)];
    6263        node["modelMatrix"] = recalculateModelMatrix(node);
    6364        node["drawMode"] = gl.LINES;
    … …  
    9697                        }
    9798                        //Scale vertices
    9899                        xyz = vec3.fromValues(x[i], y[i], z[i]);
    99                         magnitude = vec3.length(xyz) + md.geometry.surface[i] * surfacescale;
     100                        magnitude = vec3.length(xyz) + md.geometry.surface[i] * vertexscale;
    100101                        vec3.normalize(direction, xyz);
    101102                        vec3.scale(vertex, direction, magnitude);
    102103                        vertices[vertices.length] = vertex[0];
Note: See TracBrowser for help on using the repository browser.