Changeset 12093


Ignore:
Timestamp:
04/20/12 15:02:46 (13 years ago)
Author:
Mathieu Morlighem
Message:

Merging TriMesh and TriMeshRifts

Location:
issm/trunk-jpl/src
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/Makefile.am

    r12074 r12093  
    793793                        ./modules/TriMeshx/TriMeshx.h\
    794794                        ./modules/TriMeshx/TriMeshx.cpp\
    795                         ./modules/TriMeshRiftsx/TriMeshRiftsx.h\
    796                         ./modules/TriMeshRiftsx/TriMeshRiftsx.cpp\
    797795                        ./modules/PointCloudFindNeighborsx/PointCloudFindNeighborsx.h\
    798796                        ./modules/PointCloudFindNeighborsx/PointCloudFindNeighborsx.cpp\

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

    r12063 r12093  
    2020/*}}}*/
    2121
    22 void TriMeshRiftsx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area,bool order){
     22void TriMeshRiftsx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area){
    2323
    2424        /*indexing: */
    … …  
    4848                in.numberofpoints+=contour->nods;
    4949        }
    50         if (rifts){
    51                 for (i=0;i<rifts->Size();i++){
    52                         contour=(Contour*)rifts->GetObjectByOffset(i);
    53                         in.numberofpoints+=contour->nods;
    54                 }
    55         }
     50        for (i=0;i<rifts->Size();i++){
     51                contour=(Contour*)rifts->GetObjectByOffset(i);
     52                in.numberofpoints+=contour->nods;
     53        }
     54
    5655        /*number of point attributes: */
    5756        in.numberofpointattributes=1;
    … …  
    6968                }
    7069        }
    71         if(rifts){
    72                 for (i=0;i<rifts->Size();i++){
    73                         contour=(Contour*)rifts->GetObjectByOffset(i);
    74                         for (j=0;j<contour->nods;j++){
    75                                 in.pointlist[2*counter+0]=contour->x[j];
    76                                 in.pointlist[2*counter+1]=contour->y[j];
    77                                 counter++;
    78                         }
     70        for (i=0;i<rifts->Size();i++){
     71                contour=(Contour*)rifts->GetObjectByOffset(i);
     72                for (j=0;j<contour->nods;j++){
     73                        in.pointlist[2*counter+0]=contour->x[j];
     74                        in.pointlist[2*counter+1]=contour->y[j];
     75                        counter++;
    7976                }
    8077        }
    … …  
    9491                in.numberofsegments+=contour->nods;
    9592        }
    96         if(rifts){
    97                 for(i=0;i<rifts->Size();i++){
    98                         contour=(Contour*)rifts->GetObjectByOffset(i);
    99                         /*for rifts, we have one less segment as we have vertices*/
    100                         in.numberofsegments+=contour->nods-1;
    101                 }
     93        for(i=0;i<rifts->Size();i++){
     94                contour=(Contour*)rifts->GetObjectByOffset(i);
     95                /*for rifts, we have one less segment as we have vertices*/
     96                in.numberofsegments+=contour->nods-1;
    10297        }
    10398       
    … …  
    122117        }
    123118        counter2=counter;
    124         if(rifts){
    125                 for (i=0;i<rifts->Size();i++){
    126                         contour=(Contour*)rifts->GetObjectByOffset(i);
    127                         for (j=0;j<(contour->nods-1);j++){
    128                                 in.segmentlist[2*counter2+0]=counter;
    129                                 in.segmentlist[2*counter2+1]=counter+1;
    130                                 in.segmentmarkerlist[counter2]=2+i;
    131                                 counter2++;
    132                                 counter++;
    133                         }
    134                         counter++;
    135                 }
     119        for (i=0;i<rifts->Size();i++){
     120                contour=(Contour*)rifts->GetObjectByOffset(i);
     121                for (j=0;j<(contour->nods-1);j++){
     122                        in.segmentlist[2*counter2+0]=counter;
     123                        in.segmentlist[2*counter2+1]=counter+1;
     124                        in.segmentmarkerlist[counter2]=2+i;
     125                        counter2++;
     126                        counter++;
     127                }
     128                counter++;
    136129        }
    137130       
    … …  
    196189
    197190        /*Order segments so that their normals point outside the domain: */
    198         if(order){
    199                 OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
    200         }
     191        OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
    201192
    202193        /*Output : */

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

    r12063 r12093  
    1111
    1212/* local prototypes: */
    13 void TriMeshRiftsx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area,bool order);
     13void TriMeshRiftsx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area);
    1414
    1515#endif  /* _TRIMESHX_H */

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

    r12061 r12093  
    2020/*}}}*/
    2121
    22 void TriMeshx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,double area,bool order){
     22void TriMeshx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area){
    2323
    2424        /*indexing: */
    … …  
    3535
    3636        /*intermediary: */
    37         int      counter,backcounter;
     37        int      counter,counter2,backcounter;
    3838        Contour* contour=NULL;
    3939
    … …  
    4848                in.numberofpoints+=contour->nods;
    4949        }
     50        for (i=0;i<rifts->Size();i++){
     51                contour=(Contour*)rifts->GetObjectByOffset(i);
     52                in.numberofpoints+=contour->nods;
     53        }
     54
    5055        /*number of point attributes: */
    5156        in.numberofpointattributes=1;
    … …  
    6368                }
    6469        }
     70        for (i=0;i<rifts->Size();i++){
     71                contour=(Contour*)rifts->GetObjectByOffset(i);
     72                for (j=0;j<contour->nods;j++){
     73                        in.pointlist[2*counter+0]=contour->x[j];
     74                        in.pointlist[2*counter+1]=contour->y[j];
     75                        counter++;
     76                }
     77        }
    6578       
    6679        /*fill in the point attribute list: */
    67         in.pointattributelist = (REAL *) xmalloc(in.numberofpoints * in.numberofpointattributes * sizeof(REAL));
     80        in.pointattributelist = (REAL*)xmalloc(in.numberofpoints*in.numberofpointattributes*sizeof(REAL));
    6881        for (i=0;i<in.numberofpoints;i++) in.pointattributelist[i] = 0.0;
    6982       
    … …  
    7790                contour=(Contour*)domain->GetObjectByOffset(i);
    7891                in.numberofsegments+=contour->nods;
     92        }
     93        for(i=0;i<rifts->Size();i++){
     94                contour=(Contour*)rifts->GetObjectByOffset(i);
     95                /*for rifts, we have one less segment as we have vertices*/
     96                in.numberofsegments+=contour->nods-1;
    7997        }
    8098       
    … …  
    97115                 counter++;
    98116                 backcounter=counter;
     117        }
     118        counter2=counter;
     119        for (i=0;i<rifts->Size();i++){
     120                contour=(Contour*)rifts->GetObjectByOffset(i);
     121                for (j=0;j<(contour->nods-1);j++){
     122                        in.segmentlist[2*counter2+0]=counter;
     123                        in.segmentlist[2*counter2+1]=counter+1;
     124                        in.segmentmarkerlist[counter2]=2+i;
     125                        counter2++;
     126                        counter++;
     127                }
     128                counter++;
    99129        }
    100130       
    … …  
    159189
    160190        /*Order segments so that their normals point outside the domain: */
    161         if(order){
    162                 OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
    163         }
     191        OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
    164192
    165193        /*Output : */

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

    r12056 r12093  
    77
    88#include "string.h"
    9 
    109#include "../../Container/Container.h"
    1110#include "../../objects/objects.h"
    1211
    1312/* local prototypes: */
    14 void TriMeshx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,double area,bool order);
     13void TriMeshx(Matrix** pindex,Vector** px,Vector** py,Matrix** psegments,Vector** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area);
    1514
    1615#endif  /* _TRIMESHX_H */

  • issm/trunk-jpl/src/c/shared/Exp/DomainOutlineRead.cpp

    r11935 r12093  
    1414
    1515int DomainOutlineRead(int* pnprof,int** pprofnvertices,double*** ppprofx,double*** ppprofy,bool** pclosed,char* domainname,bool whole=true){
    16 
    1716       
    1817        /*indexing: */
    … …  
    128127DataSet* DomainOutlineRead(char* domainname,bool whole=true){
    129128
    130         /*indexing: */
    131         int i;
    132 
    133129        /*intermediary: */
    134         int nprof;
    135         int* profnvertices=NULL;
    136         double** pprofx=NULL;
    137         double** pprofy=NULL;
    138 
    139         Contour* contour=NULL;
     130        int       nprof;
     131        int      *profnvertices = NULL;
     132        double  **pprofx        = NULL;
     133        double  **pprofy        = NULL;
     134        Contour  *contour       = NULL;
    140135
    141136        /*output: */
    142137        DataSet* domain=NULL;
    143138
    144         /*get domain outline from intermediary function:*/
    145         DomainOutlineRead(&nprof,&profnvertices,&pprofx, &pprofy, NULL,domainname,whole);
     139        /*If domainname is an empty string, return empty dataset*/
     140        if (strcmp(domainname,"")==0){
     141                nprof=0;
     142        }
     143        else{
     144                DomainOutlineRead(&nprof,&profnvertices,&pprofx, &pprofy, NULL,domainname,whole);
     145        }
    146146
    147147        /*now create dataset of contours: */
    148148        domain=new DataSet(0);
    149149
    150         for(i=0;i<nprof;i++){
     150        for(int i=0;i<nprof;i++){
    151151                domain->AddObject(new Contour(i,profnvertices[i],pprofx[i],pprofy[i],1));
    152152        }
    153 
    154153        return domain;
    155154}

  • issm/trunk-jpl/src/modules/TriMesh/TriMesh.cpp

    r12025 r12093  
    88       
    99        /* input: */
    10         char*  domainname=NULL;
    11         double area;
    12         bool   order;
     10        char   *domainname = NULL;
     11        char   *riftsname  = NULL;
     12        double  area;
    1313
    1414        /*intermediary: */
    15         DataSet* domain=NULL;
     15        DataSet *domain = NULL;
     16        DataSet *rifts  = NULL;
    1617
    1718        /* output: */
    18         Matrix* index=NULL;
    19         Vector* x=NULL;
    20         Vector* y=NULL;
    21         Matrix* segments=NULL;
    22         Vector* segmentmarkerlist=NULL;
     19        Matrix *index             = NULL;
     20        Vector *x                 = NULL;
     21        Vector *y                 = NULL;
     22        Matrix *segments          = NULL;
     23        Vector *segmentmarkerlist = NULL;
    2324
    2425        /*Boot module: */
    … …  
    3031        /*Fetch data needed for meshing: */
    3132        FetchData(&domainname,DOMAINOUTLINE);
     33        FetchData(&riftsname,RIFTSOUTLINE);
    3234        FetchData(&area,AREA);
    33         FetchData(&order,ORDER);
    3435
    3536        /*Read domain outline: */
    36         domain=DomainOutlineRead(domainname,false);
     37        domain = DomainOutlineRead(domainname,false);
     38        rifts  = DomainOutlineRead(riftsname,false);
    3739
    3840        /*call x core: */
    39         TriMeshx(&index,&x,&y,&segments,&segmentmarkerlist,domain,area,order);
    40        
     41        TriMeshx(&index,&x,&y,&segments,&segmentmarkerlist,domain,rifts,area);
     42
    4143        /*write outputs: */
    4244        WriteData(INDEX,index);
    … …  
    4850        /*free ressources: */
    4951        delete domain;
     52        delete rifts;
    5053        xdelete_module(&index);
    5154        xdelete_module(&x);
    … …  
    6164{
    6265        printf("\n");
    63         printf("   usage: [index,x,y,segments,segmentmarkers]=TriMesh(domainoutlinefilename,area,ordered) \n");
     66        printf("   usage: [index,x,y,segments,segmentmarkers]=TriMesh(domainoutlinefilename,rifts,area) \n");
    6467        printf("      where: index,x,y defines a triangulation, segments is an array made \n");
    6568        printf("      of exterior segments to the mesh domain outline, segmentmarkers is an array flagging each segment, \n");
    6669        printf("      outlinefilename an Argus domain outline file, \n");
    6770        printf("      area is the maximum area desired for any element of the resulting mesh, \n");
    68         printf("      and ordered is a bool that determines whether segments are output in the \n");
    69         printf("      order they are made by Triangle (ie none), or ordered counter clockwise around the domain outline.\n");
    7071        printf("\n");
    7172}

  • issm/trunk-jpl/src/modules/TriMesh/TriMesh.h

    r12032 r12093  
    3131/* serial input macros: */
    3232#define DOMAINOUTLINE  (mxArray *)prhs[0]
    33 #define AREA           (mxArray *)prhs[1]
    34 #define ORDER          (mxArray *)prhs[2]
     33#define RIFTSOUTLINE   (mxArray *)prhs[1]
     34#define AREA           (mxArray *)prhs[2]
    3535/* serial output macros: */
    3636#define INDEX             (mxArray**)&plhs[0]
    … …  
    4444/* serial input macros: */
    4545#define DOMAINOUTLINE PyTuple_GetItem(args,0)
    46 #define AREA          PyTuple_GetItem(args,1)
    47 #define ORDER         PyTuple_GetItem(args,2)
     46#define RIFTSOUTLINE  PyTuple_GetItem(args,1)
     47#define AREA          PyTuple_GetItem(args,2)
    4848/* serial output macros: */
    4949#define INDEX             output,0

  • issm/trunk-jpl/src/modules/matlab/Makefile.am

    r12090 r12093  
    3535                                TriaSearch\
    3636                                TriMesh\
    37                                 TriMeshRifts\
    3837                                TriMeshProcessRifts\
    3938                                Xy2ll
    … …  
    156155                          ../TriMesh/TriMesh.h
    157156
    158 TriMeshRifts_SOURCES = ../TriMeshRifts/TriMeshRifts.cpp\
    159                           ../TriMeshRifts/TriMeshRifts.h
    160 
    161157TriMeshProcessRifts_SOURCES = ../TriMeshProcessRifts/TriMeshProcessRifts.cpp\
    162158                          ../TriMeshProcessRifts/TriMeshProcessRifts.h
Note: See TracChangeset for help on using the changeset viewer.