source: issm/oecreview/Archive/21724-22754/ISSM-22659-22660.diff

Last change on this file was 22755, checked in by Mathieu Morlighem, 7 years ago

CHG: added 21724-22754
File size: 4.2 KB

  • ../trunk-jpl/src/wrappers/InterpFromGridToMesh/InterpFromGridToMesh.js

     
     1/**
     2 * INTERPFROMGRIDTOMESH - interpolation from a grid onto a list of points
     3 *
     4 * This function interpolates a field defined on a grid to a list of points based on a bilinear interpolation.
     5 *
     6 * Usage:
     7 *      var data_mesh=InterpFromGridToMesh(xIn,yIn,dataIn,xMeshIn,yMeshIn,defaultValue);\
     8 *
     9 *      xIn,yIn                                         : coordinates of matrix data. (x and y must be in increasing order)
     10 *      dataIn                                          : matrix holding the data to be interpolated onto the mesh
     11 *      xMeshIn,yMeshIn                         : coordinates of the points onto which we interpolate
     12 *      defaultValue (optional)         : default value if no data is found (holes)
     13 *      dataMesh                                        : array of mesh interpolated data
     14 */
     15function InterpFromGridToMesh(xIn,yIn,dataIn,xMeshIn,yMeshIn,defaultValue) {
     16        /*
     17                Variables
     18        */
     19        //{{{
     20        var data                        = {};
     21        var dataMesh            = {};
     22        var dataMeshPtr         = {};
     23        var ddata                       = {};
     24        var ddataHeap           = {};
     25        var ddataPtr            = {};
     26        var defaultValue        = 0; // Default value for defaultValue :)
     27        var dx                          = {};
     28        var dxHeap                      = {};
     29        var dxMesh                      = {};
     30        var dxMeshHeap          = {};
     31        var dxMeshPtr           = {};
     32        var dxPtr                       = {};
     33        var dy                          = {};
     34        var dyHeap                      = {};
     35        var dyMesh                      = {};
     36        var dyMeshHeap          = {};
     37        var dyMeshPtr           = {};
     38        var dyPtr                       = {};
     39        var ndata                       = {};
     40        var nods                        = 0;
     41        var nx                          = {};
     42        var nxMesh                      = {};
     43        var ny                          = {};
     44        var nyMesh                      = {};
     45        var pdataMesh           = {};
     46        var x                           = {};
     47        var xMesh                       = {};
     48        var y                           = {};
     49        var yMesh                       = {};
     50        //}}}
     51       
     52       
     53        /*
     54                Retrieve default value
     55        */
     56        //{{{
     57        if (arguments.length === 6) {
     58                var defaultValue = arguments[5];
     59        }
     60        //}}}
     61       
     62       
     63        /*
     64                Dynamic allocations
     65        */
     66        //{{{
     67       
     68        /*
     69                Input
     70        */
     71        //{{{
     72        dx                      = new Float64Array(xIn);
     73        nx                      = dx.length * dx.BYTES_PER_ELEMENT;
     74        dxPtr           = Module._malloc(nx);
     75        dxHeap          = new Uint8Array(Module.HEAPU8.buffer, dxPtr, nx);
     76        dxHeap.set(new Uint8Array(dx.buffer));
     77        x                       = dxHeap.byteOffset;
     78       
     79        dy                      = new Float64Array(yIn);
     80        ny                      = dy.length * dy.BYTES_PER_ELEMENT;
     81        dyPtr           = Module._malloc(ny);
     82        dyHeap          = new Uint8Array(Module.HEAPU8.buffer, dyPtr, ny);
     83        dyHeap.set(new Uint8Array(dy.buffer));
     84        y                       = dyHeap.byteOffset;
     85       
     86        ddata           = new Float64Array(dataIn);
     87        ndata           = ddata.length * ddata.BYTES_PER_ELEMENT;
     88        ddataPtr        = Module._malloc(ndata);
     89        ddataHeap       = new Uint8Array(Module.HEAPU8.buffer, ddataPtr, ndata);
     90        ddataHeap.set(new Uint8Array(ddata.buffer));
     91        data            = ddataHeap.byteOffset;
     92       
     93        dxMesh          = new Float64Array(xMeshIn);
     94        nxMesh          = dxMesh.length * dxMesh.BYTES_PER_ELEMENT;
     95        dxMeshPtr       = Module._malloc(nxMesh);
     96        dxMeshHeap      = new Uint8Array(Module.HEAPU8.buffer, dxMeshPtr, nxMesh);
     97        dxMeshHeap.set(new Uint8Array(dxMesh.buffer));
     98        xMesh           = dxMeshHeap.byteOffset;
     99       
     100        dyMesh          = new Float64Array(yMeshIn);
     101        nyMesh          = dyMesh.length * dyMesh.BYTES_PER_ELEMENT;
     102        dyMeshPtr       = Module._malloc(nyMesh);
     103        dyMeshHeap      = new Uint8Array(Module.HEAPU8.buffer, dyMeshPtr, nyMesh);
     104        dyMeshHeap.set(new Uint8Array(dyMesh.buffer));
     105        yMesh           = dyMeshHeap.byteOffset;
     106       
     107        nods            = xIn.length;
     108       
     109       
     110        /*
     111                Output
     112        */
     113        dataMeshPtr = Module._malloc(4);
     114        //}}}
     115       
     116        //}}}
     117       
     118       
     119        /*
     120                Declare InterpFromGridToMesh module
     121        */
     122        //{{{
     123        InterpFromGridToMeshModule = Module.cwrap(
     124                'InterpFromGridToMeshModule',
     125                'number',
     126                [
     127                        'number',
     128                        'number',
     129                        'number',
     130                        'number',
     131                        'number',
     132                        'number',
     133                        'number'
     134                ]
     135        );
     136        //}}}
     137       
     138       
     139        /*
     140                Call InterpFromGridToMesh module
     141        */
     142        //{{{
     143        InterpFromGrid2MeshModule(
     144                dataMeshPtr,
     145                x,
     146                y,
     147                data,
     148                xMesh,
     149                yMesh,
     150                nods,
     151                defaultValue
     152        );
     153        //}}}
     154       
     155       
     156        /*
     157                Dynamic copying from heap
     158        */
     159        //{{{
     160        dataMeshPtr     = Module.getValue(pdataMesh, 'i32');
     161        dataMesh        = Module.HEAP64.slice(dataMeshPtr / 8, dataMeshPtr / 8 + nods);
     162        //}}}
     163       
     164       
     165        /*
     166                Free resources
     167        */
     168        //{{{
     169        Module._free(pdataMesh);
     170        //}}}
     171       
     172       
     173        return dataMesh;
     174}
     175 No newline at end of file
Note: See TracBrowser for help on using the repository browser.