ContourToMeshx.h File Reference

#include "../../shared/shared.h"
#include "../../classes/classes.h"

Go to the source code of this file.

Data Structures
struct	ContourToMeshxThreadStruct

Functions
int	ContourToMeshx (double **pin_nods, double **pin_elem, double *index, double *x, double *y, Contours *contours, char *interptype, int nel, int nods, int edgevalue)
void *	ContourToMeshxt (void *vContourToMeshxThreadStruct)

Function Documentation

ContourToMeshx()

int ContourToMeshx	(	double **	pin_nods,
		double **	pin_elem,
		double *	index,
		double *	x,
		double *	y,
		Contours *	contours,
		char *	interptype,
		int	nel,
		int	nods,
		int	edgevalue
	)

Definition at line 12 of file ContourToMeshx.cpp.

                                                                                                                                                                {
 
   /*Contour:*/
   double value;
 
   /*output: */
   double*  in_nod;
   double*  in_elem;
   in_nod   = xNewZeroInit<double>(nods);
   in_elem  = xNewZeroInit<double>(nel);
 
   /*initialize thread parameters: */
   ContourToMeshxThreadStruct gate;
   gate.contours  = contours;
   gate.nods      = nods;
   gate.edgevalue = edgevalue;
   gate.in_nod    = in_nod;
   gate.x         = x;
   gate.y         = y;
 
   /*launch the thread manager with ContourToMeshxt as a core: */
   LaunchThread(ContourToMeshxt,(void*)&gate,_NUMTHREADS_);
 
   /*Take care of the case where an element interpolation has been requested: */
   if ((strcmp(interptype,"element")==0) || (strcmp(interptype,"element and node")==0)){
      for(int n=0;n<nel;n++){
         if ( (in_nod[ (int)*(index+3*n+0) -1] == 1) && (in_nod[ (int)*(index+3*n+1) -1] == 1) && (in_nod[ (int)*(index+3*n+2) -1] == 1) ){
            value=1.; in_elem[n]=value;
         }
      }
   }
 
   /*Assign output pointers: */
   *pin_nod=in_nod;
   *pin_elem=in_elem;
 
   return 1;
}

ContourToMeshxt()

void* ContourToMeshxt

(

void *

vContourToMeshxThreadStruct

)

Definition at line 13 of file ContourToMeshxt.cpp.

                                            {
 
   /*gate variables :*/
   ContourToMeshxThreadStruct *gate        = NULL;
   pthread_handle             *handle      = NULL;
   int  i,i1,i0;
 
   /*recover handle and gate: */
   handle          = (pthread_handle*)vpthread_handle;
   gate            = (ContourToMeshxThreadStruct*)handle->gate;
   int my_thread   = handle->id;
   int num_threads = handle->num;
 
   /*recover parameters :*/
   Contours* contours  = gate->contours;
   int       nods      = gate->nods;
   int       edgevalue = gate->edgevalue;
   double   *in_nod    = gate->in_nod;
   double   *x         = gate->x;
   double   *y         = gate->y;
 
   /*distribute indices across threads :*/
   PartitionRange(&i0,&i1,nods,num_threads,my_thread);
 
   /*Loop through all contours: */
   for (i=0;i<contours->Size();i++){
      Contour<double>* contour=(Contour<double>*)contours->GetObjectByOffset(i);
      IsInPoly(in_nod,contour->x,contour->y,contour->nods,x,y,i0,i1,edgevalue);
   }
 
   return NULL;
}