Changeset 21828


Ignore:
Timestamp:
07/20/17 04:16:12 (8 years ago)
Author:
Mathieu Morlighem
Message:

CHG: simplified the arguments of InterpFromMeshToGrid

Location:
issm/trunk-jpl/src
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/modules/InterpFromMeshToGridx/InterpFromMeshToGridx.cpp

    r17207 r21828  
    66#include "../../shared/shared.h"
    77
    8 void InterpFromMeshToGridx(double** px_m,double** py_m,double** pgriddata,double* index_mesh, double* x_mesh, double* y_mesh, int nods,int nels, double* data_mesh, int data_length, double xmin,double ymax,double xposting,double yposting,int nlines,int ncols,double default_value) {
    9 
    10         /*Output*/
    11         double* griddata=NULL;
    12         double* x_grid=NULL;
    13         double* y_grid=NULL;
     8void InterpFromMeshToGridx(double** pgriddata,double* index_mesh, double* x_mesh, double* y_mesh, int nods,int nels, double* data_mesh,int data_length,double* x_grid,double* y_grid,int nlines,int ncols,double default_value){
    149
    1510        /*Intermediary*/
    16         int    i,j,n;
     11        int    i,j;
    1712        int    i1,i2,j1,j2;
    1813        int    interpolation_type;
    19         bool   debug;
    20         int    xflip,yflip;
    2114        double area;
    2215        double area_1,area_2,area_3;
    … …  
    2821
    2922        /*some checks*/
    30         if (nels<1 || nods<3 || nlines<1 || ncols<1 || xposting==0 || yposting==0){
    31                 _error_("nothing to be done according to the mesh given in input");
    32         }
     23        if(nels<1 || nods<3 || nlines<2 || ncols<2) _error_("nothing to be done according to the mesh given in input");
    3324
    3425        /*figure out what kind of interpolation is needed*/
    35         if (data_length==nods){
    36                 interpolation_type=1;
    37         }
    38         else if (data_length==nels){
    39                 interpolation_type=2;
    40         }
    41         else{
    42                 _error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
    43         }
     26        if(data_length==nods)      interpolation_type=1;
     27        else if(data_length==nels) interpolation_type=2;
     28        else _error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
    4429
    4530        /*First, allocate pointers: */
    46         griddata=xNewZeroInit<double>(nlines*ncols);
    47         x_grid=xNewZeroInit<double>(ncols);
    48         y_grid=xNewZeroInit<double>(nlines);
     31        double* griddata=xNewZeroInit<double>(nlines*ncols);
    4932
    5033        /*Set debug to 1 if there are lots of elements*/
    51         debug=(bool)((double)ncols*nlines*nels >= 5*pow(10.,10.));
     34        bool debug=(bool)((double)ncols*nlines*nels >= 5.e10);
    5235
    5336        /*Initialize coordintes and griddata*/
    54         for(i=0;i<nlines;i++){
    55                 for(j=0;j<ncols; j++){
    56                         griddata[i*ncols+j]=default_value;
    57                 }
    58         }
     37        for(i=0;i<nlines;i++) for(j=0;j<ncols; j++) griddata[i*ncols+j]=default_value;
     38
    5939        /*figure out if x or y are flipped*/
    60         if (xposting<0) xflip=1;
    61         else xflip=0;
    62         if (yposting<0) yflip=1;
    63         else yflip=0;
     40        bool xflip = false;
     41        bool yflip = false;
     42        if (x_grid[1]-x_grid[0]<0) xflip=true;
     43        if (y_grid[1]-y_grid[0]<0) yflip=true;
    6444
    65         /*Get extreme coordinates of the grid*/
    66         if (xflip){
    67                 for(i=0;i<ncols; i++) x_grid[ncols-1-i] = xmin - xposting*i;
     45        /*Get min/max coordinates of the grid*/
     46        double xposting = x_grid[1]-x_grid[0];
     47        double yposting = y_grid[1]-y_grid[0];
     48        if(xflip){
    6849                x_grid_min=x_grid[ncols-1];
    6950                x_grid_max=x_grid[0];
    7051        }
    7152        else{
    72                 for(i=0;i<ncols; i++) x_grid[i]= xmin + xposting*i;
    7353                x_grid_min=x_grid[0];
    7454                x_grid_max=x_grid[ncols-1];
    7555        }
    76         if (yflip){
    77                 for(i=0;i<nlines;i++) y_grid[i] = ymax + yposting*i;
     56        if(yflip){
    7857                y_grid_min=y_grid[nlines-1];
    7958                y_grid_max=y_grid[0];
    8059        }
    8160        else{
    82                 for(i=0;i<nlines;i++) y_grid[nlines-1-i]= ymax - yposting*i;
    8361                y_grid_min=y_grid[0];
    8462                y_grid_max=y_grid[nlines-1];
    … …  
    8664
    8765        /*Loop over the elements*/
    88         for (n=0;n<nels;n++){
     66        for(int n=0;n<nels;n++){
    8967
    9068                /*display current iteration*/
    91                 if (debug && fmod((double)n,(double)100)==0)
     69                if(debug && fmod((double)n,(double)100)==0)
    9270                 _printf_("\r      interpolation progress: "<<setw(6)<<setprecision(2)<<double(n)/double(nels)*100<<"%   ");
    9371
    … …  
    9573                x_tria_min=x_mesh[(int)index_mesh[3*n+0]-1]; x_tria_max=x_tria_min;
    9674                y_tria_min=y_mesh[(int)index_mesh[3*n+0]-1]; y_tria_max=y_tria_min;
    97                 for (i=1;i<3;i++){
     75                for(i=1;i<3;i++){
    9876                        if(x_mesh[(int)index_mesh[3*n+i]-1]<x_tria_min) x_tria_min=x_mesh[(int)index_mesh[3*n+i]-1];
    9977                        if(x_mesh[(int)index_mesh[3*n+i]-1]>x_tria_max) x_tria_max=x_mesh[(int)index_mesh[3*n+i]-1];
    … …  
    10381
    10482                /*if the current triangle is not in the grid, continue*/
    105                 if ( (x_tria_min>x_grid_max) || (x_tria_max<x_grid_min) || (y_tria_min>y_grid_max) || (y_tria_max<y_grid_min) ) continue;
     83                if( (x_tria_min>x_grid_max) || (x_tria_max<x_grid_min) || (y_tria_min>y_grid_max) || (y_tria_max<y_grid_min) ) continue;
    10684
    10785                /*Get indices i and j that form a square around the currant triangle*/
    108                 if (yflip){
     86                if(yflip){
    10987                        i1=max(0,       (int)floor((y_tria_max-y_grid_max)/yposting)-1);
    11088                        i2=min(nlines-1,(int)ceil((y_tria_min-y_grid_max)/yposting));
    … …  
    11492                        i2=min(nlines-1,(int)ceil((y_tria_max-y_grid_min)/yposting));
    11593                }
    116                 if (xflip){
     94                if(xflip){
    11795                        j1=max(0,      (int)floor((x_tria_max-x_grid_max)/xposting)-1);
    11896                        j2=min(ncols-1,(int)ceil((x_tria_min-x_grid_max)/xposting));
    … …  
    130108
    131109                /*Go through x_grid and y_grid and interpolate if necessary*/
    132                 for (i=i1;i<=i2;i++){
     110                for(i=i1;i<=i2;i++){
    133111
    134112                        //exit if y not between y_tria_min and y_tria_max
    … …  
    147125                                                        - (y_mesh[(int)index_mesh[3*n+0]-1]-y_mesh[(int)index_mesh[3*n+2]-1])*(x_grid[j]-x_mesh[(int)index_mesh[3*n+2]-1]))/area;
    148126                                /*Get third area coordinate = 1-area1-area2*/
    149                                 area_3=1-area_1-area_2;
     127                                area_3=1.-area_1-area_2;
    150128
    151129                                /*is the current point in the current element?*/
    152                                 if (area_1>-10e-12 && area_2>-10e-12 && area_3>-10e-12){
     130                                if(area_1>-10e-12 && area_2>-10e-12 && area_3>-10e-12){
    153131
    154132                                        /*Yes ! compute the value on the point*/
    155                                         if (interpolation_type==1){
     133                                        if(interpolation_type==1){
    156134                                                /*nodal interpolation*/
    157135                                                data_value=area_1*data_mesh[(int)index_mesh[3*n+0]-1]+area_2*data_mesh[(int)index_mesh[3*n+1]-1]+area_3*data_mesh[(int)index_mesh[3*n+2]-1];
    … …  
    169147                }
    170148        }
    171         if (debug)
    172          _printf_("\r      interpolation progress: "<<fixed<<setw(6)<<setprecision(2)<<100.<<"%  \n");
     149        if(debug) _printf_("\r      interpolation progress: "<<fixed<<setw(6)<<setprecision(2)<<100.<<"%  \n");
    173150
    174151        /*Assign output pointers:*/
    175152        *pgriddata=griddata;
    176         *px_m=x_grid;
    177         *py_m=y_grid;
    178153}

  • issm/trunk-jpl/src/c/modules/InterpFromMeshToGridx/InterpFromMeshToGridx.h

    r9242 r21828  
    88#include "../../toolkits/toolkits.h"
    99
    10 void InterpFromMeshToGridx(double** px_m,double** py_m,double** pgriddata,double* index_mesh, double* x_mesh, double* y_mesh, int nods,int nels, double* data_mesh, int data_length, double xmin,double ymax,double xposting,double yposting,int nlines,int ncols,double default_value);
     10void InterpFromMeshToGridx(double** pgriddata,double* index_mesh, double* x_mesh, double* y_mesh, int nods,int nels, double* data_mesh,int data_length,double* x_grid,double* y_grid,int nlines,int ncols,double default_value);
    1111
    1212#endif /* _INTERPFROMMESHTOGRIDX_H */

  • issm/trunk-jpl/src/m/kml/kmlimagesc.m

    r13007 r21828  
    4646
    4747%figure out nlines and ncols in our image
    48 nlines=(maxlat-minlat)/posting;
    49 ncols=(maxlong-minlong)/posting;
     48x_m = minlong:posting:maxlong;
     49y_m = minlat:posting:maxlat;
    5050
    5151%regrid to lat,long grid
    52 [x_m,y_m,field]=InterpFromMeshToGrid(md.mesh.elements,md.mesh.long,md.mesh.lat,field,minlong,maxlat,posting,posting,nlines,ncols,NaN);
     52field=InterpFromMeshToGrid(md.mesh.elements,md.mesh.long,md.mesh.lat,field,x_m,y_m,NaN);
    5353field=flipud(field);
    5454

  • issm/trunk-jpl/src/m/miscellaneous/diagnostics.m

    r21455 r21828  
    4646                yposting=getfieldvalue(options,'velposting',500);
    4747
    48                 xmin=min(md.mesh.x); ymax=max(md.mesh.y);
    49                 ncols=(max(md.mesh.x)-min(md.mesh.x))/xposting+1;
    50                 nlines=(max(md.mesh.y)-min(md.mesh.y))/yposting+1;
     48                xm=min(md.mesh.x):posting:max(md.mesh.x);
     49                ym=min(md.mesh.y):posting:max(md.mesh.y);
    5150               
    52                 [xm,ym,vel]=InterpFromMeshToGrid(md.mesh.elements,md.mesh.x,md.mesh.y,vel,xmin,ymax,xposting,yposting,nlines,ncols,0);
     51                vel=InterpFromMeshToGrid(md.mesh.elements,md.mesh.x,md.mesh.y,vel,xm,ym,0.);
    5352                vel=uint16(flipud(vel));
    5453

  • issm/trunk-jpl/src/m/modules/InterpFromMeshToGrid.m

    r20875 r21828  
    1 function [x_m,y_m,griddata] = InterpFromMeshToGrid(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value);
     1function grid = InterpFromMeshToGrid(index,x,y,data,xgrid,ygrid,default_value);
    22%INTERPFROMMESHTOGRID - Interpolation of a data defined on a mesh onto a grid
     3%
     4%   Usage:
     5%      grid = InterpFromMeshToGrid(index,x,y,data,xgrid,ygrid,default_value)
    36%
    47%   This function is a multi-threaded mex file that interpolates a field defined on a triangular
    … …  
    811%   meshdata:   vertex values of data to be interpolated
    912%
    10 %   xmin,ymax,posting,nlines,ncols: parameters that define the grid
    11 %   default_value:      value of points located out of the mesh
     13%   xgrid,ygrid:  parameters that define the grid
     14%   default_value: value of points located out of the mesh
    1215
    1316% Check usage
    14 if nargin~=11
     17if nargin~=7
    1518        help InterpFromMeshToGrid
    1619        error('Wrong usage (see above)');
    … …  
    1821
    1922% Call mex module
    20 [x_m,y_m,griddata] = InterpFromMeshToGrid_matlab(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value);
     23grid = InterpFromMeshToGrid_matlab(index,x,y,data,xgrid,ygrid,default_value);

  • issm/trunk-jpl/src/m/modules/InterpFromMeshToGrid.py

    r20909 r21828  
    11from InterpFromMeshToGrid_python import InterpFromMeshToGrid_python
    22
    3 def InterpFromMeshToGrid(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value):
     3def InterpFromMeshToGrid(index,x,y,data,xgrid,ygrid,default_value):
    44        """
    55        INTERPFROMMESHTOGRID - Interpolation of a data defined on a mesh onto a grid
    … …  
    1111                meshdata:       vertex values of data to be interpolated
    1212
    13                 xmin,ymax,posting,nlines,ncols: parameters that define the grid
     13                xgrid,ygrid,:   parameters that define the grid
    1414                default_value:  value of points located out of the mesh
    1515        """
    1616        # Call mex module
    17         x_m,y_m,griddata=InterpFromMeshToGrid_python(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value)
     17        grid=InterpFromMeshToGrid_python(index,x,y,data,xgrid,ygrid,default_value)
    1818        # Return
    19         return x_m,y_m,griddate
     19        return grid

  • issm/trunk-jpl/src/m/plot/kmlgridded.m

    r14195 r21828  
    2525
    2626%Interpolating data on grid
    27 [x_m y_m data_grid]=InterpFromMeshToGrid(elements,x,y,data,xlim(1),ylim(2),post,post,round(diff(ylim)/post),round(diff(xlim)/post),NaN);
     27x_m = xlim(1):post:xlim(2);
     28y_m = ylim(1):post:ylim(2);
     29data_grid=InterpFromMeshToGrid(elements,x,y,data,x_m,y_m,NaN);
    2830if size(data_grid,1)<3 | size(data_grid,2)<3,
    2931        error('data_grid size too small, check posting and units');

  • issm/trunk-jpl/src/m/plot/plot_googlemaps.m

    r20834 r21828  
    6262%Prepare grid
    6363if size(md.radaroverlay.x,1)==1 | size(md.radaroverlay.x,2)==1,
    64         xmin=min(md.radaroverlay.x);
    65         ymax=max(md.radaroverlay.y);
    66         xspacing=md.radaroverlay.x(2)-md.radaroverlay.x(1);
    67         yspacing=md.radaroverlay.y(2)-md.radaroverlay.y(1);
    68         nlines=length(md.radaroverlay.y);
    69         ncols =length(md.radaroverlay.x);
    70                 [x_m y_m data_grid]=InterpFromMeshToGrid(elements,x/getfieldvalue(options,'unit',1),y/getfieldvalue(options,'unit',1),...
    71                         data,xmin,ymax,xspacing,yspacing,nlines,ncols,NaN);
     64        x_m = md.radaroverlay.x;
     65        y_m = md.radaroverlay.y;
     66        data_grid=InterpFromMeshToGrid(elements,x/getfieldvalue(options,'unit',1),y/getfieldvalue(options,'unit',1),data,x_m,y_m,NaN);
    7267else
    7368        X = md.radaroverlay.x;

  • issm/trunk-jpl/src/m/plot/plot_gridded.m

    r21240 r21828  
    2323
    2424%Interpolating data on grid
    25 [x_m y_m data_grid]=InterpFromMeshToGrid(elements,x,y,data,xlim(1),ylim(2),postx,posty,round(diff(ylim)/posty),round(diff(xlim)/postx),NaN);
     25x_m = xlim(1):postx:xlim(2);
     26y_m = ylim(1):posty:ylim(2);
     27data_grid=InterpFromMeshToGrid(elements,x,y,data,x_m,y_m,NaN);
    2628data_grid_save = data_grid;
    2729if size(data_grid,1)<3 | size(data_grid,2)<3,

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

    r21783 r21828  
    5858
    5959%InterpFromMeshToGrid
    60 xmin=min(md.radaroverlay.x);
    61 ymax=max(md.radaroverlay.y);
    62 xspacing=(max(md.radaroverlay.x)-min(md.radaroverlay.x))/(length(md.radaroverlay.x) -1);
    63 yspacing=(max(md.radaroverlay.y)-min(md.radaroverlay.y))/(length(md.radaroverlay.y) -1);
    64 if(md.radaroverlay.x(end)-md.radaroverlay.x(1)<0)
    65         xspacing= -xspacing;
    66 end
    67 if(md.radaroverlay.y(end)-md.radaroverlay.y(1)<0)
    68         yspacing= -yspacing;
    69 end
    70 nlines=length(md.radaroverlay.y);
    71 ncols =length(md.radaroverlay.x);
    7260disp('Interpolating data on grid...');
     61x_m = md.radaroverlay.x;
     62y_m = md.radaroverlay.y;
    7363if radaronly,
    74         x_m=xmin:xspacing:xmin+ncols*xspacing;
    75         y_m=ymax-nlines*yspacing:yspacing:ymax;
    76         data_grid=NaN*ones(nlines,ncols);
     64        data_grid=NaN(size(radar));
    7765else
    78         [x_m y_m data_grid]=InterpFromMeshToGrid(elements,x/getfieldvalue(options,'unit',1),y/getfieldvalue(options,'unit',1),...
    79                 data,xmin,ymax,xspacing,yspacing,nlines,ncols,NaN);
     66        data_grid=InterpFromMeshToGrid(elements,x/getfieldvalue(options,'unit',1),y/getfieldvalue(options,'unit',1),data,x_m,y_m,NaN);
    8067end
    8168
    … …  
    152139
    153140%Plot:
    154 imagesc(md.radaroverlay.x*getfieldvalue(options,'unit',1),md.radaroverlay.y*getfieldvalue(options,'unit',1),image_rgb);set(gca,'YDir','normal');
     141imagesc(x_m*getfieldvalue(options,'unit',1),y_m*getfieldvalue(options,'unit',1),image_rgb);set(gca,'YDir','normal');
    155142
    156143%last step: mesh overlay?

  • issm/trunk-jpl/src/wrappers/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp

    r20877 r21828  
    1212        _printf0_("\n");
    1313        _printf0_("   Usage:\n");
    14         _printf0_("      [x_m,y_m,griddata]=InterpFromMeshToGrid(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value)\n");
     14        _printf0_("      grid=InterpFromMeshToGrid(index,x,y,data,x_grid,y_grid,default_value)\n");
    1515        _printf0_("\n");
    1616        _printf0_("      index,x,y: delaunay triangulation defining the mesh.\n");
    1717        _printf0_("      meshdata: vertex values of data to be interpolated.\n");
    18         _printf0_("      xmin,ymax,posting,nlines,ncols: parameters that define the grid\n");
     18        _printf0_("      xgrid,ygrid: parameters that define the grid\n");
    1919        _printf0_("      default_value: value of points located out of the mesh.\n");
    2020        _printf0_("\n");
    … …  
    2222WRAPPER(InterpFromMeshToGrid_python){
    2323
    24         /*input datasets: */
     24        /*inputs */
    2525        double* index=NULL;
    26         int     nel;
    2726        double* x=NULL;
    28         int     nods;
    2927        double* y=NULL;
     28        int     nel,nods;
    3029        double* meshdata=NULL;
    3130        int     meshdata_length;
    32         double  xmin;
    33         double  ymax;
    34         double  xposting;
    35         double  yposting;
    36         int     nlines,ncols;
     31        double* xgrid=NULL;
     32        double* ygrid=NULL;
     33        int     nlines,ncols,test;
    3734        double  default_value;
    3835
    39         /* output datasets: */
     36        /* outputs */
    4037        double* griddata=NULL;
    41         double* x_m=NULL;
    42         double* y_m=NULL;
    4338
    4439        /*Boot module: */
    … …  
    5146
    5247        /*Input datasets: */
    53         FetchData(&index,&nel,NULL,INDEX);
    54         FetchData(&x,&nods,NULL,X);
    55         FetchData(&y,NULL,NULL,Y);
    56         FetchData(&meshdata,&meshdata_length,NULL,MESHDATA);
    57         FetchData(&xmin,XMIN);
    58         FetchData(&ymax,YMAX);
    59         FetchData(&xposting,XPOSTING);
    60         FetchData(&yposting,YPOSTING);
    61         FetchData(&nlines,NLINES);
    62         FetchData(&ncols,NCOLS);
     48        FetchData(&index,&nel,&test,INDEX);
     49        if(test!=3) _error_("size not supported yet");
     50        FetchData(&x,&nods,X);
     51        FetchData(&y,&test,Y);
     52        if(test!=nods) _error_("size not supported yet");
     53        FetchData(&meshdata,&meshdata_length,MESHDATA);
     54        FetchData(&xgrid,&ncols,XGRID);
     55        FetchData(&ygrid,&nlines,YGRID);
    6356        FetchData(&default_value,DEFAULTVALUE);
    6457
    6558        /*Call core of computation: */
    66         InterpFromMeshToGridx(&x_m,&y_m,&griddata,index,x,y,nods,nel,meshdata,meshdata_length,xmin,ymax,xposting,yposting,nlines,ncols,default_value);
     59        InterpFromMeshToGridx(&griddata,index,x,y,nods,nel,meshdata,meshdata_length,xgrid,ygrid,nlines,ncols,default_value);
    6760
    6861        /*Write results: */
    69         WriteData(XM,x_m,ncols);
    70         WriteData(YM,y_m,nlines);
    7162        WriteData(GRIDDATA,griddata,nlines,ncols);
    7263
    … …  
    7768        xDelete<double>(meshdata);
    7869        xDelete<double>(griddata);
    79         xDelete<double>(x_m);
    80         xDelete<double>(y_m);
     70        xDelete<double>(xgrid);
     71        xDelete<double>(ygrid);
    8172
    8273        /*end module: */

  • issm/trunk-jpl/src/wrappers/InterpFromMeshToGrid/InterpFromMeshToGrid.h

    r21086 r21828  
    3333#define Y            prhs[2]
    3434#define MESHDATA     prhs[3]
    35 #define XMIN         prhs[4]
    36 #define YMAX         prhs[5]
    37 #define XPOSTING     prhs[6]
    38 #define YPOSTING     prhs[7]
    39 #define NLINES       prhs[8]
    40 #define NCOLS        prhs[9]
    41 #define DEFAULTVALUE prhs[10]
     35#define XGRID        prhs[4]
     36#define YGRID        prhs[5]
     37#define DEFAULTVALUE prhs[6]
    4238/* serial output macros: */
    43 #define XM (mxArray**)&plhs[0]
    44 #define YM (mxArray**)&plhs[1]
    45 #define GRIDDATA (mxArray**)&plhs[2]
     39#define GRIDDATA (mxArray**)&plhs[0]
    4640#endif
    4741
    … …  
    5246#define Y            PyTuple_GetItem(args,2)
    5347#define MESHDATA     PyTuple_GetItem(args,3)
    54 #define XMIN         PyTuple_GetItem(args,4)
    55 #define YMAX         PyTuple_GetItem(args,5)
    56 #define XPOSTING     PyTuple_GetItem(args,6)
    57 #define YPOSTING     PyTuple_GetItem(args,7)
    58 #define NLINES       PyTuple_GetItem(args,8)
    59 #define NCOLS        PyTuple_GetItem(args,9)
     48#define XGRID        PyTuple_GetItem(args,4)
     49#define YGRID        PyTuple_GetItem(args,5)
    6050#define DEFAULTVALUE PyTuple_GetItem(args,10)
    6151/* serial output macros: */
    62 #define XM output,0
    63 #define YM output,1
    64 #define GRIDDATA output,2
     52#define GRIDDATA output,0
    6553#endif
    6654
    6755/* serial arg counts: */
    6856#undef NLHS
    69 #define NLHS  3
     57#define NLHS  1
    7058#undef NRHS
    71 #define NRHS  11
     59#define NRHS  7
    7260
    7361#endif  /* _INTERPFROMMESHTOGRID_H*/
Note: See TracChangeset for help on using the changeset viewer.