Ejemplo n.º 1
0
int advectParticle(pScene sc,pMesh mesh) {
  pParticle   pp;
  pStream     st;
  pTetra      pt1;
  pPoint      ppt;
  double      v[4];
  int         i,j,k,l,base;

  if ( ddebug )  printf("advect particles\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);
  if ( !sc->stream )  return(0);
  st = sc->stream;

  if ( mesh->ntet && !hashTetra(mesh) ) return(0);

  st->xmin = mesh->xmin - mesh->xtra;
  st->ymin = mesh->ymin - mesh->ytra;
  st->zmin = mesh->zmin - mesh->ztra;
  st->xmax = mesh->xmax - mesh->xtra;
  st->ymax = mesh->ymax - mesh->ytra;
  st->zmax = mesh->zmax - mesh->ztra;

  sc->par.cumpertime = 0.0;
  sc->par.advtim     = 0;

  /* init list */
  sc->slist = (GLuint*)calloc(MAX_LST,sizeof(GLuint));
  if ( !sc->slist )  return(0);

  /* point positions */
  base = ++mesh->mark;
  for (i=1; i<=mesh->np; i++) {
    ppt = &mesh->point[i];
    ppt->mark = base;
  }
  for (k=1; k<=mesh->ntet; k++)
    mesh->tetra[k].cpt = 0;

  l = 1;
  for (k=1; k<=st->nbstl; k++) {
    pp = &tp[k];
    pp->ct = 0.0;
    st->listp[l++] = pp->pos[pp->cur][0];
    st->listp[l++] = pp->pos[pp->cur][1];
    st->listp[l++] = pp->pos[pp->cur][2];
    pp->cur = 1;
  }

  ++base;
  l = 1;
  for (k=1; k<=st->nbstl; k++) {
    pp = &tp[k];
    pp->pos[1][0] = st->listp[l++];
    pp->pos[1][1] = st->listp[l++];
    pp->pos[1][2] = st->listp[l++];

    tp[k].nsdep = locateTetra(mesh,pp->nsdep,++mesh->mark,pp->pos[1],pp->cb);
    if ( !pp->nsdep ) {
      for (j=1; j<=mesh->ntet; j++) {
        pt1 = &mesh->tetra[j];
        if ( pt1->mark != mesh->mark && inTetra(mesh,j,pp->pos[1],pp->cb) )
          break;
      }
      if ( j > mesh->ntet )  continue;
      else
        pp->nsdep = j;
    }
    pp->norm  = field3DInterp(mesh,tp[k].nsdep,tp[k].cb,v);
    pp->size  = sizeTetra(mesh,tp[k].nsdep);
    if ( pp->size == 0.0 )
      pp->step = EPS*sc->dmax;
    else
      pp->step = HSIZ * min(pp->size,pp->norm);
    pp->step = min(0.05*sc->par.dt,pp->step);
    pp->flag =  1;
    pp->cur  =  1;
    colorParticle(sc,pp);

    for (i=2; i<=sc->par.nbpart; i++) {
      pp->pos[i][0] = pp->pos[1][0];
      pp->pos[i][1] = pp->pos[1][1];
      pp->pos[i][2] = pp->pos[1][2];
    }
  }

  return(1);
}
Ejemplo n.º 2
0
/**
 * \brief Find eigenvalues and vectors of a 2x2 matrix.
 * \param mm pointer toward the matrix.
 * \param lambda pointer toward the output eigenvalues.
 * \param vp eigenvectors.
 * \return 1.
 *
 * \warning not used for now
 */
int _MMG5_eigen2(double *mm,double *lambda,double vp[2][2]) {
  double   m[3],dd,a1,xn,ddeltb,rr1,rr2,ux,uy;

  /* init */
  ux = 1.0;
  uy = 0.0;

  /* normalize */
  memcpy(m,mm,3*sizeof(double));
  xn = fabs(m[0]);
  if ( fabs(m[1]) > xn )  xn = fabs(m[1]);
  if ( fabs(m[2]) > xn )  xn = fabs(m[2]);
  if ( xn < _MG_EPSD2 ) {
    lambda[0] = lambda[1] = 0.0;
    vp[0][0] = 1.0;
    vp[0][1] = 0.0;
    vp[1][0] = 0.0;
    vp[1][1] = 1.0;
    return(1);
  }
  xn = 1.0 / xn;
  m[0] *= xn;
  m[1] *= xn;
  m[2] *= xn;

  if ( egal(m[1],0.0) ) {
    rr1 = m[0];
    rr2 = m[2];
    goto vect;
  }

  /* eigenvalues of jacobian */
  a1     = -(m[0] + m[2]);
  ddeltb = a1*a1 - 4.0 * (m[0]*m[2] - m[1]*m[1]);

  if ( ddeltb < 0.0 ) {
    fprintf(stderr,"  Delta: %f\n",ddeltb);
    ddeltb = 0.0;
  }
  ddeltb = sqrt(ddeltb);

  if ( fabs(a1) < _MG_EPS ) {
    rr1 = 0.5 * sqrt(ddeltb);
    rr2 = -rr1;
  }
  else if ( a1 < 0.0 ) {
    rr1 = 0.5 * (-a1 + ddeltb);
    rr2 = (-m[1]*m[1] + m[0]*m[2]) / rr1;
  }
  else if ( a1 > 0.0 ) {
    rr1 = 0.5 * (-a1 - ddeltb);
    rr2 = (-m[1]*m[1] + m[0]*m[2]) / rr1;
  }
  else {
    rr1 = 0.5 * ddeltb;
    rr2 = -rr1;
  }

vect:
  xn = 1.0 / xn;
  lambda[0] = rr1 * xn;
  lambda[1] = rr2 * xn;

  /* eigenvectors */
  a1 = m[0] - rr1;
  if ( fabs(a1)+fabs(m[1]) < _MG_EPS ) {
    if (fabs(lambda[1]) < fabs(lambda[0]) ) {
      ux = 1.0;
      uy = 0.0;
    }
    else {
      ux = 0.0;
      uy = 1.0;
    }
  }
  else if ( fabs(a1) < fabs(m[1]) ) {
    ux = 1.0;
    uy = -a1 / m[1];
  }
  else if ( fabs(a1) > fabs(m[1]) ) {
    ux = -m[1] / a1;
    uy = 1.0;
  }
  else if ( fabs(lambda[1]) > fabs(lambda[0]) ) {
    ux = 0.0;
    uy = 1.0;
  }
  else {
    ux = 1.0;
    uy = 0.0;
  }

  dd = sqrt(ux*ux + uy*uy);
  dd = 1.0 / dd;
  if ( fabs(lambda[0]) > fabs(lambda[1]) ) {
    vp[0][0] =  ux * dd;
    vp[0][1] =  uy * dd;
  }
  else {
    vp[0][0] =  uy * dd;
    vp[0][1] = -ux * dd;
  }

  /* orthogonal vector */
  vp[1][0] = -vp[0][1];
  vp[1][1] =  vp[0][0];

  return(1);
}
Ejemplo n.º 3
0
GLuint alt2dList(pScene sc,pMesh mesh,int geomtype,float shrink,float altcoef) {
  pTriangle  pt,pt1;
  pMaterial  pm;
  pQuad      pq;
  pPoint     p0,p1,p2,p3;
  pSolution  ps0,ps1,ps2,ps3;
  GLuint     dlist;
  double     ax,ay,az,bx,by,bz,dd,kc,rgb[4];
  float      cx,cy,cz,n[3];
  int       *adj,k,m,ia,iadr;
  ubyte     *voy;
  triangle   t,t1,t2;
  static double hsv[3] = { 0.0, 1.0, 0.80 };
  static float  nn[3] = {1.0, 0.0, 0.0 };

  /* default */
  if ( ddebug ) printf("create 2d elevation map list\n");

  if ( geomtype == LTria && !mesh->nt )  return(0);
  if ( geomtype == LQuad && !mesh->nq )  return(0);
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);

  mesh->zmin = altcoef*mesh->bbmin;
  mesh->zmax = altcoef*mesh->bbmax;
  if ( mesh->bbmin*mesh->bbmax < 0.0 ) {
    mesh->ztra = mesh->zmin;
  }
  else {
    mesh->ztra = 0.95 * mesh->zmin;
  }

  switch (geomtype) {
  case LTria:
    if ( ddebug ) printf("create triangle list %d\n",mesh->nt);
    
    if ( mesh->typage == 1 ) {
      if ( mesh->nt && !hashTria(mesh) )    return(0);
    }

    glBegin(GL_TRIANGLES);

    for (m=0; m<sc->par.nbmat; m++) {
      pm = &sc->material[m];
      k  = pm->depmat[LTria];
      if ( !k || pm->flag )  continue;

      while ( k != 0 ) {
        pt = &mesh->tria[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }

        p0 = &mesh->point[pt->v[0]];
        p1 = &mesh->point[pt->v[1]];
        p2 = &mesh->point[pt->v[2]];
      
        if ( mesh->typage == 1 )
          ps0 = ps1 = ps2 = &mesh->sol[k];
        else {
          ps0  = &mesh->sol[pt->v[0]];
          ps1  = &mesh->sol[pt->v[1]];
          ps2  = &mesh->sol[pt->v[2]];
        }
        cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.0;
        cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.0;
        cz = (ps0->bb + ps1->bb + ps2->bb) / 3.0;

        t.a[0] = shrink*(p0->c[0]-cx) + cx;
        t.a[1] = shrink*(p0->c[1]-cy) + cy;
        t.a[2] = shrink*(altcoef*ps0->bb-cz) + cz - 0.25*mesh->ztra;

        t.b[0] = shrink*(p1->c[0]-cx) + cx;
        t.b[1] = shrink*(p1->c[1]-cy) + cy;
        t.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
        
        t.c[0] = shrink*(p2->c[0]-cx) + cx;
        t.c[1] = shrink*(p2->c[1]-cy) + cy;
        t.c[2] = shrink*(altcoef*ps2->bb-cz) + cz - 0.25*mesh->ztra;
        
        /* compute normal */
        ax = p1->c[0] - p0->c[0];
        ay = p1->c[1] - p0->c[1];
        az = p1->c[2] - p0->c[2];
        bx = p2->c[0] - p0->c[0];
        by = p2->c[1] - p0->c[1];
        bz = p2->c[2] - p0->c[2];
        n[0] = ay*bz - az*by;
        n[1] = az*bx - ax*bz;
        n[2] = ax*by - ay*bx;
        dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
        if ( dd > 0.0 ) {
      dd = 1.0 / sqrt(dd);
      n[0] *= dd;
      n[1] *= dd;
      n[2] *= dd;
        }

        memcpy(t.na,n,3*sizeof(float));
        memcpy(t.nb,n,3*sizeof(float));
        memcpy(t.nc,n,3*sizeof(float));

        t.va = ps0->bb;
        t.vb = ps1->bb;
        t.vc = ps2->bb;

        if ( mesh->typage == 2 ) 
          cutTriangle(sc,t);

        else {
          if ( t.va < sc->iso.val[0] ) 
            t.va = sc->iso.val[0];  
          else if ( t.va > sc->iso.val[MAXISO-1] )
            t.va = sc->iso.val[MAXISO-1];
          for (ia=0; ia<MAXISO-1; ia++)
            if ( t.va < sc->iso.val[ia] )  break;
          kc = (t.va-sc->iso.val[ia-1]) / (sc->iso.val[ia] - sc->iso.val[ia-1]);
          hsv[0] = sc->iso.col[ia-1]*(1.0-kc)+sc->iso.col[ia]*kc;
          hsvrgb(hsv,rgb);

          glColor4dv(rgb);
          glNormal3fv(t.na);
          glVertex3fv(t.a);
          glVertex3fv(t.b);
          glVertex3fv(t.c);

          /* add quads to sides (thanks to F. Lagoutiere) */
          iadr = 3*(k-1)+1;
          adj  = &mesh->adja[iadr];
          voy  = &mesh->voy[iadr];

          if ( adj[0] && adj[0] < k ) {
            pt1 = &mesh->tria[ adj[0] ]; 
            p3  = &mesh->point[ pt1->v[voy[0]] ];
            ps1 = &mesh->sol[ adj[0] ];
            
            cx = (p1->c[0] + p2->c[0] + p3->c[0]) / 3.0;
            cy = (p1->c[1] + p2->c[1] + p3->c[1]) / 3.0;
            cz = ps1->bb;

            memcpy(t1.a,t.b,3*sizeof(float));
            memcpy(t1.b,t.c,3*sizeof(float));
            memcpy(t1.c,t.b,3*sizeof(float));
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps0->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);

            memcpy(t1.a,t.c,3*sizeof(float));
            memcpy(t1.b,t.c,3*sizeof(float));
            memcpy(t1.c,t.b,3*sizeof(float));
            t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps1->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);
          }
          if ( adj[1] && adj[1] < k ) {
            pt1 = &mesh->tria[ adj[1] ]; 
            p3  = &mesh->point[ pt1->v[voy[1]] ];
            ps1 = &mesh->sol[ adj[1] ];
            
            cx = (p0->c[0] + p2->c[0] + p3->c[0]) / 3.0;
            cy = (p0->c[1] + p2->c[1] + p3->c[1]) / 3.0;
            cz = ps1->bb;

            memcpy(t1.a,t.a,3*sizeof(float));
            memcpy(t1.b,t.c,3*sizeof(float));
            memcpy(t1.c,t.a,3*sizeof(float));
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps0->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);

            memcpy(t1.a,t.c,3*sizeof(float));
            memcpy(t1.b,t.c,3*sizeof(float));
            memcpy(t1.c,t.a,3*sizeof(float));
            t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps1->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);
          }
          if ( adj[2] && adj[2] < k ) {
            pt1 = &mesh->tria[ adj[2] ]; 
            p3  = &mesh->point[ pt1->v[voy[2]] ];
            ps1 = &mesh->sol[ adj[2] ];
            
            cx = (p0->c[0] + p1->c[0] + p3->c[0]) / 3.0;
            cy = (p0->c[1] + p1->c[1] + p3->c[1]) / 3.0;
            cz = ps1->bb;

            memcpy(t1.a,t.a,3*sizeof(float));
            memcpy(t1.b,t.b,3*sizeof(float));
            memcpy(t1.c,t.a,3*sizeof(float));
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps0->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);

            memcpy(t1.a,t.b,3*sizeof(float));
            memcpy(t1.b,t.b,3*sizeof(float));
            memcpy(t1.c,t.a,3*sizeof(float));
            t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
            t1.va = ps0->bb;
            t1.vb = ps1->bb;
            t1.vc = ps1->bb;
            memcpy(t1.na,nn,3*sizeof(float));
            memcpy(t1.nb,nn,3*sizeof(float));
            memcpy(t1.nc,nn,3*sizeof(float));
            cutTriangle(sc,t1);
          }
        }

        k = pt->nxt;
      }
    }
    glEnd();
    break;
    
  case LQuad:
    if ( ddebug ) printf("create quadrilateral list %d\n",mesh->nq);

    glBegin(GL_TRIANGLES);
    for (m=0; m<sc->par.nbmat; m++) {
      pm = &sc->material[m];
      k  = pm->depmat[LQuad];
      if ( !k || pm->flag )  continue;

      while ( k != 0 ) {
        pq = &mesh->quad[k];
        if ( !pq->v[0] ) {
          k = pq->nxt;
          continue;
        }
        
        p0 = &mesh->point[pq->v[0]];
        p1 = &mesh->point[pq->v[1]];
        p2 = &mesh->point[pq->v[2]];
        p3 = &mesh->point[pq->v[3]];
      
        if ( mesh->typage == 1 )
          ps0 = ps1 = ps2 = ps3 = &mesh->sol[k];
        else {
      ps0 = &mesh->sol[pq->v[0]];
      ps1 = &mesh->sol[pq->v[1]];
      ps2 = &mesh->sol[pq->v[2]];
      ps3 = &mesh->sol[pq->v[3]];
    }
        cx = 0.25 * (p0->c[0] + p1->c[0] + p2->c[0] + p3->c[0]);
        cy = 0.25 * (p0->c[1] + p1->c[1] + p2->c[1] + p3->c[1]);
        cz = 0.25 * (ps0->bb + ps1->bb + ps2->bb + ps3->bb);

        t.a[0] = t2.a[0] = shrink*(p0->c[0]-cx) + cx;
        t.a[1] = t2.a[1] = shrink*(p0->c[1]-cy) + cy;
        t.a[2] = t2.a[2] = shrink*(altcoef*ps0->bb-cz) + cz - 0.25*mesh->ztra;

        t.b[0] = shrink*(p1->c[0]-cx) + cx;
        t.b[1] = shrink*(p1->c[1]-cy) + cy;
        t.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra;
        
        t.c[0] = t2.b[0] = shrink*(p2->c[0]-cx) + cx;
        t.c[1] = t2.b[1] = shrink*(p2->c[1]-cy) + cy;
        t.c[2] = t2.b[2] = shrink*(altcoef*ps2->bb-cz) + cz - 0.25*mesh->ztra;

        t2.c[0] = shrink*(p3->c[0]-cx) + cx;
        t2.c[1] = shrink*(p3->c[1]-cy) + cy;
        t2.c[2] = shrink*(altcoef*ps3->bb-cz) + cz - 0.25*mesh->ztra;

        /* compute normal */
        ax = p1->c[0] - p0->c[0];
        ay = p1->c[1] - p0->c[1];
        az = p1->c[2] - p0->c[2];
        bx = p2->c[0] - p0->c[0];
        by = p2->c[1] - p0->c[1];
        bz = p2->c[2] - p0->c[2];
        n[0] = ay*bz - az*by;
        n[1] = az*bx - ax*bz;
        n[2] = ax*by - ay*bx;
        dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
        if ( dd > 0.0f ) {
      dd = 1.0f / sqrt(dd);
      n[0] *= dd;
      n[1] *= dd;
      n[2] *= dd;
        }
        memcpy(t.na,n,3*sizeof(float));
        memcpy(t.nb,n,3*sizeof(float));
        memcpy(t.nc,n,3*sizeof(float));
        memcpy(t2.na,n,3*sizeof(float));
        memcpy(t2.nb,n,3*sizeof(float));
        memcpy(t2.nc,n,3*sizeof(float));

        t.va = t2.va = ps0->bb;
        t.vb = ps1->bb;
        t.vc = t2.vb = ps2->bb;
        t2.vc = ps3->bb;

        cutTriangle(sc,t);
        cutTriangle(sc,t2);

        k = pq->nxt;
      }
    }
    glEnd();
    break;
  }
  glEndList();

  return(dlist);
}
Ejemplo n.º 4
0
int createParticle(pScene sc,pMesh mesh) {
  pParticle   pp;
  pStream     st;
  pMaterial   pm;
  pTetra      pt1;
  pTriangle   pt;
  pPoint      ppt;
  double      v[4],cx,cy,cz;
  int         i,j,k,l,nmat,nbp,base;

  if ( ddebug )  printf("create particles\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);

  if ( sc->stream ) { 
    st = sc->stream;
    if ( st->listp )  free(st->listp);
    free(sc->stream);
  }
  sc->stream     = createStream(sc,mesh);
  sc->par.cumtim = 0.0;
  sc->par.advtim = 0;
  assert(sc->stream);
  st = sc->stream;

  fprintf(stdout," Creating particles :");  fflush(stdout);
  st->nbstl = 0;

  base = ++mesh->mark;
  pt   = &mesh->tria[refitem];
  nmat = matRef(sc,pt->ref);
  pm   = &sc->material[nmat];
  k    = pm->depmat[LTria];
  if ( !k || pm->flag )  return(0);

  /* point positions */
  for (i=1; i<=mesh->np; i++) {
    ppt = &mesh->point[i];
    ppt->mark = base;
  }
  if ( sc->par.nbpart >= MAX_PRT )
    sc->par.nbpart = MAX_PRT;

  ++base;
  l   = 1;
  nbp = 0;
  while ( k != 0 && st->nbstl < MAX_LST-1 ) {
    pt = &mesh->tria[k];
    if ( pt->v[0] ) {
      cx = cy = cz = 0.0;
      for (i=0; i<3; i++) {
        ppt = &mesh->point[pt->v[i]];
        cx += 0.33 * ppt->c[0];
        cy += 0.33 * ppt->c[1];
        cz += 0.33 * ppt->c[2];
        ppt->flag = 1;
      }  
      st->listp[l++] = cx;
      st->listp[l++] = cy;
      st->listp[l++] = cz;
      ++st->nbstl;
      if ( st->nbstl > MAX_LST-1 ) break;
      k = pt->nxt;
    }
  }
  fprintf(stdout,"%d\n",st->nbstl);
  if ( !st->nbstl )  return(0);

  /* init positions */
  tp = calloc((st->nbstl+1),sizeof(Particle));
  assert(tp);
  for (k=1; k<=st->nbstl; k++)
    tp[k].nsdep = mesh->ntet / 2;

  for (k=1; k<=mesh->ntet; k++)
    mesh->tetra[k].cpt = 0;

  l = 1;
  for (k=1; k<=st->nbstl; k++) {
    pp = &tp[k];
    pp->pos[1][0] = st->listp[l++];
    pp->pos[1][1] = st->listp[l++];
    pp->pos[1][2] = st->listp[l++];

    tp[k].nsdep = locateTetra(mesh,pp->nsdep,++mesh->mark,pp->pos[1],pp->cb);

    if ( !pp->nsdep ) {
      for (j=1; j<=mesh->ntet; j++) {
        pt1 = &mesh->tetra[j];
        if ( pt1->mark != mesh->mark && inTetra(mesh,j,pp->pos[1],pp->cb) )
          break;
      }
      if ( j > mesh->ntet )  return(0);
      else
        pp->nsdep = j;
    }
    pp->norm  = field3DInterp(mesh,tp[k].nsdep,tp[k].cb,v);
    pp->size  = sizeTetra(mesh,tp[k].nsdep);
    if ( pp->size == 0.0 )
      pp->step = EPS*sc->dmax;
    else
      pp->step = HSIZ * min(pp->size,pp->norm);
    pp->step = min(0.05*sc->par.dt,pp->step);
    pp->flag =  1;
    pp->cur  =  1;
    colorParticle(sc,pp);

    for (i=2; i<=sc->par.nbpart; i++) {
      pp->pos[i][0] = pp->pos[1][0];
      pp->pos[i][1] = pp->pos[1][1];
      pp->pos[i][2] = pp->pos[1][2];
    }
  }

  return(1);
}
Ejemplo n.º 5
0
/* build list of tetrahedra */
GLuint listTetraMap(pScene sc,pMesh mesh,ubyte clip) {
  pMaterial  pm;
  pTetra     pt;
  pPoint     p0,p1,p2;
  pSolution  ps0,ps1,ps2;
  GLint      dlist = 0;
  float      cx,cy,cz,ax,ay,az,bx,by,bz,d,n[3];
  int        k,l,m;
  triangle   t;

  /* default */
  if ( !mesh->ntet )  return(0);
  if ( ddebug ) printf("create display list map / TETRA\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);

  // By Leo: get number of triangles to render tet colors correctly
  int boundary_faces = mesh->nt;

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);
#ifdef IGL
  bool transp = sc->igl_params->tet_color[3] < 0.999;
  int old_depth_func =0;
  glGetIntegerv(GL_DEPTH_FUNC,&old_depth_func);
  if ( transp )
  {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glDepthFunc(GL_ALWAYS);
    sc->igl_params->alpha_holder = sc->igl_params->tet_color[3];
  }else
  {
    sc->igl_params->alpha_holder = 1.0;
  }
#endif

  /* build list */
  for (m=0; m<sc->par.nbmat; m++) {
    pm = &sc->material[m];
    k  = pm->depmat[LTets];
    if ( !k || pm->flag )  continue;

    glBegin(GL_TRIANGLES);
    while ( k != 0 ) {
      pt = &mesh->tetra[k];
      if ( !pt->v[0] || (clip && !pt->clip) ) {
        k = pt->nxt;
        continue;
      }
      /* build 4 faces */
      cx = cy = cz = 0.0f;
      for (l=0; l<4; l++) {
    p0  = &mesh->point[pt->v[l]];
    cx += p0->c[0];
        cy += p0->c[1];
        cz += p0->c[2];
      }
      cx /= 4.;
      cy /= 4.;
      cz /= 4.;

      for (l=0; l<4; l++) {
    p0 = &mesh->point[pt->v[ct[l][0]]];
    p1 = &mesh->point[pt->v[ct[l][1]]];
    p2 = &mesh->point[pt->v[ct[l][2]]];

        /* compute face normal */
    ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2];
    bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2];
    n[0] = ay*bz - az*by;
    n[1] = az*bx - ax*bz;
    n[2] = ax*by - ay*bx;
    d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
    if ( d > 0.0f ) {
      d = 1.0f / sqrt(d);
      n[0] *= d;  
          n[1] *= d;  
          n[2] *= d;
    }

        /* store triangle */
        t.a[0] = sc->shrink*(p0->c[0]-cx)+cx;
        t.a[1] = sc->shrink*(p0->c[1]-cy)+cy;
        t.a[2] = sc->shrink*(p0->c[2]-cz)+cz;

        t.b[0] = sc->shrink*(p1->c[0]-cx)+cx;
        t.b[1] = sc->shrink*(p1->c[1]-cy)+cy;
        t.b[2] = sc->shrink*(p1->c[2]-cz)+cz;

        t.c[0] = sc->shrink*(p2->c[0]-cx)+cx;
        t.c[1] = sc->shrink*(p2->c[1]-cy)+cy; 
        t.c[2] = sc->shrink*(p2->c[2]-cz)+cz; 
        
        /* store normals */
        memcpy(t.na,n,3*sizeof(float));
        memcpy(t.nb,n,3*sizeof(float));
        memcpy(t.nc,n,3*sizeof(float));

        if ( mesh->typage == 2 ) {
          /* solutions at vertices */
      ps0 = &mesh->sol[pt->v[ct[l][0]]];
      ps1 = &mesh->sol[pt->v[ct[l][1]]];
      ps2 = &mesh->sol[pt->v[ct[l][2]]];
          t.va = ps0->bb;
      t.vb = ps1->bb;
      t.vc = ps2->bb;
        }
        else {
          /* solution at element */  
          ps0 = &mesh->sol[k+boundary_faces];
      t.va = t.vb = t.vc = ps0->bb;
        }
        /* color interpolation */
        cutTriangle(sc,t);
      }
      k = pt->nxt;
    }
    glEnd();
  }
#ifdef IGL
  if(transp)
  {
    glDepthFunc(old_depth_func);
    glDisable(GL_BLEND);
  }
#endif

  glEndList();
  return(dlist);
}
Ejemplo n.º 6
0
/* build list of hexahedra */
GLuint listHexaMap(pScene sc,pMesh mesh,ubyte clip) {
  pMaterial  pm;
  pHexa      ph;
  pPoint     p0,p1,p2,p3;
  pSolution  ps0,ps1,ps2,ps3;
  GLint      dlist = 0;
  double     ax,ay,az,bx,by,bz,d;
  float      n[3],cx,cy,cz;
  int        k,l,m;
  triangle   t1,t2;

  if ( !mesh->nhex )  return(0);
  if ( ddebug ) printf("create display list map / HEXA\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);

  /* build list */
  for (m=0; m<sc->par.nbmat; m++) {
    pm = &sc->material[m];
    k  = pm->depmat[LHexa];
    if ( !k || pm->flag )  continue;

    glBegin(GL_TRIANGLES);
    while ( k != 0 ) {
      ph = &mesh->hexa[k];
      if ( !ph->v[0] || (clip && !ph->clip) ) {
        k = ph->nxt;
        continue;
      }
      cx = cy = cz = 0.0f;
      for (l=0; l<8; l++) {
    p0  = &mesh->point[ph->v[l]];
    cx += p0->c[0];
        cy += p0->c[1];
        cz += p0->c[2];
      }
      cx /= 8.; 
      cy /= 8.;
      cz /= 8.;
      
      for (l=0; l<6; l++) {
    p0 = &mesh->point[ph->v[ch[l][0]]];
    p1 = &mesh->point[ph->v[ch[l][1]]];
    p2 = &mesh->point[ph->v[ch[l][2]]];
    p3 = &mesh->point[ph->v[ch[l][3]]];
        
    /* compute face normal */
    ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2];
    bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2];
    n[0] = ay*bz - az*by;
    n[1] = az*bx - ax*bz;
    n[2] = ax*by - ay*bx;
    d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
    if ( d > 0.0f ) {
      d = 1.0f / sqrt(d);
      n[0] *= d;  
          n[1] *= d;  
          n[2] *= d;
    }

        /* store triangles */
        t1.a[0] = t2.a[0] = sc->shrink*(p0->c[0]-cx)+cx;
        t1.a[1] = t2.a[1] = sc->shrink*(p0->c[1]-cy)+cy;
        t1.a[2] = t2.a[2] = sc->shrink*(p0->c[2]-cz)+cz;

        t1.b[0] = sc->shrink*(p1->c[0]-cx)+cx;
        t1.b[1] = sc->shrink*(p1->c[1]-cy)+cy;
        t1.b[2] = sc->shrink*(p1->c[2]-cz)+cz;

        t1.c[0] = t2.b[0] = sc->shrink*(p2->c[0]-cx)+cx; 
        t1.c[1] = t2.b[1] = sc->shrink*(p2->c[1]-cy)+cy; 
        t1.c[2] = t2.b[2] = sc->shrink*(p2->c[2]-cz)+cz; 

        t2.c[0] = sc->shrink*(p3->c[0]-cx)+cx; 
        t2.c[1] = sc->shrink*(p3->c[1]-cy)+cy; 
        t2.c[2] = sc->shrink*(p3->c[2]-cz)+cz; 

        /* store normals */
    memcpy(t1.na,n,3*sizeof(float));
    memcpy(t1.nb,n,3*sizeof(float));
    memcpy(t1.nc,n,3*sizeof(float));
    memcpy(t2.na,n,3*sizeof(float));
    memcpy(t2.nb,n,3*sizeof(float));
    memcpy(t2.nc,n,3*sizeof(float));

        if ( mesh->typage == 2 ) {
          /* solutions at vertices */
      ps0 = &mesh->sol[ph->v[ch[l][0]]];
      ps1 = &mesh->sol[ph->v[ch[l][1]]];
      ps2 = &mesh->sol[ph->v[ch[l][2]]];
      ps3 = &mesh->sol[ph->v[ch[l][3]]];
      t1.va = t2.va = ps0->bb;
      t1.vb = ps1->bb;
      t1.vc = t2.vb = ps2->bb;
      t2.vc = ps3->bb;
        }
        else {
          /* solution at element */
      ps0 = &mesh->sol[k];
      t1.va = t1.vb = t1.vc = ps0->bb;
      t2.va = t2.vb = t2.vc = ps0->bb;
        }
        /* color interpolation */
        cutTriangle(sc,t1);
        cutTriangle(sc,t2);
     }
     k = ph->nxt;
   }
   glEnd();
  }
  
  glEndList();
  return(dlist);
}
Ejemplo n.º 7
0
/* build list of quadrilaterals */
GLuint listQuadMap(pScene sc,pMesh mesh) {
  pMaterial  pm;
  pQuad      pq;
  pPoint     p0,p1,p2,p3;
  pSolution  ps0,ps1,ps2,ps3;
  GLint      dlist = 0;
  double     ax,ay,az,bx,by,bz,dd;
  float      cx,cy,cz,n[3];
  int        k,m,is0,is1,is2,is3;
  triangle   t1,t2;

  /* default */
  if ( !mesh->nq ) return(0);
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);
  if ( ddebug ) printf("create display list map / QUADS\n");

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);

  /* build list */
  for (m=0; m<sc->par.nbmat; m++) {
    pm = &sc->material[m];
    k  = pm->depmat[LQuad];
    if ( !k || pm->flag )  continue;

    glBegin(GL_TRIANGLES);
    while ( k != 0 ) {
      pq = &mesh->quad[k];
      if ( pq->v[0] == 0 ) {
        k = pq->nxt;
        continue;
      }
      p0 = &mesh->point[pq->v[0]];
      p1 = &mesh->point[pq->v[1]];
      p2 = &mesh->point[pq->v[2]];
      p3 = &mesh->point[pq->v[3]];
      
      /* compute normal */
      ax = p1->c[0] - p0->c[0];
      ay = p1->c[1] - p0->c[1];
      az = p1->c[2] - p0->c[2];
      bx = p2->c[0] - p0->c[0];
      by = p2->c[1] - p0->c[1];
      bz = p2->c[2] - p0->c[2];
      n[0] = ay*bz - az*by;
      n[1] = az*bx - ax*bz;
      n[2] = ax*by - ay*bx;
      dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
      if ( dd > 0.0f ) {
        dd = 1.0f / sqrt(dd);
        n[0] *= dd;
        n[1] *= dd;
        n[2] *= dd;
      }

      if ( sc->shrink < 1.0 ) {
        cx = 0.25 * (p0->c[0] + p1->c[0] + p2->c[0] + p3->c[0]);
        cy = 0.25 * (p0->c[1] + p1->c[1] + p2->c[1] + p3->c[1]);
        cz = 0.25 * (p0->c[2] + p1->c[2] + p2->c[2] + p3->c[2]);
        t1.a[0] = t2.a[0] = sc->shrink*(p0->c[0]-cx)+cx;
        t1.a[1] = t2.a[1] = sc->shrink*(p0->c[1]-cy)+cy;
        t1.a[2] = t2.a[2] = sc->shrink*(p0->c[2]-cz)+cz;

        t1.b[0] = sc->shrink*(p1->c[0]-cx)+cx;
        t1.b[1] = sc->shrink*(p1->c[1]-cy)+cy;
        t1.b[2] = sc->shrink*(p1->c[2]-cz)+cz;

        t1.c[0] = t2.b[0] = sc->shrink*(p2->c[0]-cx)+cx; 
        t1.c[1] = t2.b[1] = sc->shrink*(p2->c[1]-cy)+cy; 
        t1.c[2] = t2.b[2] = sc->shrink*(p2->c[2]-cz)+cz; 

        t2.c[0] = sc->shrink*(p3->c[0]-cx)+cx; 
        t2.c[1] = sc->shrink*(p3->c[1]-cy)+cy; 
        t2.c[2] = sc->shrink*(p3->c[2]-cz)+cz; 
      }
      else {
        t1.a[0] = t2.a[0] = p0->c[0];
        t1.a[1] = t2.a[1] = p0->c[1];
        t1.a[2] = t2.a[2] = p0->c[2];

        t1.b[0] = p1->c[0];
        t1.b[1] = p1->c[1];
        t1.b[2] = p1->c[2];

        t1.c[0] = t2.b[0] = p2->c[0]; 
        t1.c[1] = t2.b[1] = p2->c[1]; 
        t1.c[2] = t2.b[2] = p2->c[2]; 

        t2.c[0] = p3->c[0]; 
        t2.c[1] = p3->c[1]; 
        t2.c[2] = p3->c[2]; 
      }
      if ( sc->type & S_FLAT ) {
        memcpy(t1.na,n,3*sizeof(float));
        memcpy(t1.nb,n,3*sizeof(float));
        memcpy(t1.nc,n,3*sizeof(float));
        memcpy(t2.na,n,3*sizeof(float));
        memcpy(t2.nb,n,3*sizeof(float));
        memcpy(t2.nc,n,3*sizeof(float));
      }
      else {
        is0 = is1 = is2 = is3 = 0;
        if ( mesh->extra->iv ) {
          if ( pq->v[0] <= mesh->nvn )
            is0 = mesh->extra->nv[pq->v[0]];
          if ( pq->v[1] <= mesh->nvn )
            is1 = mesh->extra->nv[pq->v[1]];
          if ( pq->v[2] <= mesh->nvn )
            is2 = mesh->extra->nv[pq->v[2]];
          if ( pq->v[3] <= mesh->nvn )
            is3 = mesh->extra->nv[pq->v[3]];
        }
        if ( !is0 && pq->v[0] <= mesh->extra->iq )
          is0 = mesh->extra->nq[4*(k-1)+1];
        if ( !is1 && pq->v[1] <= mesh->extra->iq )
          is1 = mesh->extra->nq[4*(k-1)+2];
        if ( !is2 && pq->v[2] <= mesh->extra->iq )
          is2 = mesh->extra->nq[4*(k-1)+3];
        if ( !is3 && pq->v[3] <= mesh->extra->iq )
          is3 = mesh->extra->nq[4*(k-1)+4];
        
        if ( !is0 )
          memcpy(t1.na,n,3*sizeof(float));
        else {
          t1.na[0] = t2.na[0] = mesh->extra->n[3*(is0-1)+1];
          t1.na[1] = t2.na[1] = mesh->extra->n[3*(is0-1)+2];
          t1.na[2] = t2.na[2] = mesh->extra->n[3*(is0-1)+3];
        }
        if ( !is1 )
          memcpy(t1.nb,n,3*sizeof(float));
        else {
          t1.nb[0] = mesh->extra->n[3*(is1-1)+1];
          t1.nb[1] = mesh->extra->n[3*(is1-1)+2];
          t1.nb[2] = mesh->extra->n[3*(is1-1)+3];
        }
        if ( !is2 )
          memcpy(t1.nc,n,3*sizeof(float));
        else {
          t1.nc[0] = t2.nb[0] = mesh->extra->n[3*(is2-1)+1];
          t1.nc[1] = t2.nb[1] = mesh->extra->n[3*(is2-1)+2];
          t1.nc[2] = t2.nb[2] = mesh->extra->n[3*(is2-1)+3];
        }
        if ( !is3 )
          memcpy(t1.nc,n,3*sizeof(float));
        else {
          t2.nc[0] = mesh->extra->n[3*(is3-1)+1];
          t2.nc[1] = mesh->extra->n[3*(is3-1)+2];
          t2.nc[2] = mesh->extra->n[3*(is3-1)+3];
        }
      }

      if ( mesh->typage == 2 ) {
        /* solutions at vertices */
        ps0 = &mesh->sol[pq->v[0]];
        ps1 = &mesh->sol[pq->v[1]];
        ps2 = &mesh->sol[pq->v[2]];
        ps3 = &mesh->sol[pq->v[3]];
        t1.va = t2.va = ps0->bb;
        t1.vb = ps1->bb;
        t1.vc = t2.vb = ps2->bb;
        t2.vc = ps3->bb;
      }
      else {
        /* solution at element */
        ps0 = &mesh->sol[k];
        t1.va = t1.vb = t1.vc = ps0->bb;
        t2.va = t2.vb = t2.vc = ps0->bb;
      }
      /* color interpolation */
      cutTriangle(sc,t1);
      cutTriangle(sc,t2);
      k = pq->nxt;
    }
    glEnd();
  }

  glEndList();
  return(dlist);
}
Ejemplo n.º 8
0
/* metric map: use linear interpolation on values
   rather than color interpolation ! */
GLuint listTriaMap(pScene sc,pMesh mesh) {
  pMaterial  pm;
  pTriangle  pt;
  pPoint     p0,p1,p2;
  pSolution  ps0,ps1,ps2;
  GLint      dlist;
  double     ax,ay,az,bx,by,bz,dd;
  float      cx,cy,cz,n[3];
  int        k,m,is0,is1,is2;
  triangle   t;

  /* default */
  if ( !mesh->nt )  return(0);
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);
  if ( ddebug ) printf("create display list map / TRIA\n");

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);
#ifdef IGL
  bool transp = sc->material->dif[3] < 0.999;
  int old_depth_func =0;
  glGetIntegerv(GL_DEPTH_FUNC,&old_depth_func);
  if ( transp )
  {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glDepthFunc(GL_ALWAYS);
    sc->igl_params->alpha_holder = sc->material->dif[3];
  }else
  {
    sc->igl_params->alpha_holder = 1.0;
  }
#endif

  /* build list */
  for (m=0; m<sc->par.nbmat; m++) {
    pm = &sc->material[m];
    k  = pm->depmat[LTria];
    if ( !k || pm->flag )  continue;

    if ( sc->type & S_FLAT ) {
      glBegin(GL_TRIANGLES);
      while ( k != 0 ) {
        pt = &mesh->tria[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }
        p0 = &mesh->point[pt->v[0]];
        p1 = &mesh->point[pt->v[1]];
        p2 = &mesh->point[pt->v[2]];
  
        /* compute normal */
        ax = p1->c[0] - p0->c[0];
        ay = p1->c[1] - p0->c[1];
        az = p1->c[2] - p0->c[2];
        bx = p2->c[0] - p0->c[0];
        by = p2->c[1] - p0->c[1];
        bz = p2->c[2] - p0->c[2];
        n[0] = ay*bz - az*by;
        n[1] = az*bx - ax*bz;
        n[2] = ax*by - ay*bx;
        dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
        if ( dd > 0.0f ) {
          dd = 1.0f / sqrt(dd);
          n[0] *= dd;
          n[1] *= dd;
          n[2] *= dd;
        }
        memcpy(t.na,n,3*sizeof(float));
        memcpy(t.nb,n,3*sizeof(float));
        memcpy(t.nc,n,3*sizeof(float));

        if ( sc->shrink < 1.0 ) {
          cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.0;
          cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.0;
          cz = (p0->c[2] + p1->c[2] + p2->c[2]) / 3.0;
          t.a[0] = sc->shrink*(p0->c[0]-cx)+cx;
          t.a[1] = sc->shrink*(p0->c[1]-cy)+cy;
          t.a[2] = sc->shrink*(p0->c[2]-cz)+cz;
          t.b[0] = sc->shrink*(p1->c[0]-cx)+cx;
          t.b[1] = sc->shrink*(p1->c[1]-cy)+cy;
          t.b[2] = sc->shrink*(p1->c[2]-cz)+cz;
          t.c[0] = sc->shrink*(p2->c[0]-cx)+cx;
          t.c[1] = sc->shrink*(p2->c[1]-cy)+cy;
          t.c[2] = sc->shrink*(p2->c[2]-cz)+cz;
        }
        else {
          t.a[0] = p0->c[0];
          t.a[1] = p0->c[1];
          t.a[2] = p0->c[2];
          t.b[0] = p1->c[0];
          t.b[1] = p1->c[1];
          t.b[2] = p1->c[2];
          t.c[0] = p2->c[0];
          t.c[1] = p2->c[1];
          t.c[2] = p2->c[2];
        }
        if ( mesh->typage == 2 ) {
          ps0  = &mesh->sol[pt->v[0]];
          ps1  = &mesh->sol[pt->v[1]];
          ps2  = &mesh->sol[pt->v[2]];
          t.va = ps0->bb;
          t.vb = ps1->bb;
          t.vc = ps2->bb;
        }
        else {
          ps0 = &mesh->sol[k];
          t.va = t.vb = t.vc = ps0->bb;
        }
#ifdef IGL
        if(pt->ref == 1)
        {
          // Self-intersection
          float red[4] = {1.0, 0.0, 0.0, 1.0};
          red[3] = sc->material->dif[3];
          glColor4fv(red);
          glNormal3fv(n);
          glVertex3fv(t.a);
          glColor4fv(red);
          glNormal3fv(n);
          glVertex3fv(t.b);
          glColor4fv(red);
          glNormal3fv(n);
          glVertex3fv(t.c);
        }else{
#endif
        cutTriangle(sc,t);
#ifdef IGL
        }
#endif
        k = pt->nxt;
      }
      glEnd();
    }
    else {
      glBegin(GL_TRIANGLES);
      while ( k != 0 ) {
        pt = &mesh->tria[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }
        p0 = &mesh->point[pt->v[0]];
        p1 = &mesh->point[pt->v[1]];
        p2 = &mesh->point[pt->v[2]];

        /* compute normal */
        ax = p1->c[0] - p0->c[0];
        ay = p1->c[1] - p0->c[1];
        az = p1->c[2] - p0->c[2];
        bx = p2->c[0] - p0->c[0];
        by = p2->c[1] - p0->c[1];
        bz = p2->c[2] - p0->c[2];
        n[0] = ay*bz - az*by;
        n[1] = az*bx - ax*bz;
        n[2] = ax*by - ay*bx;
        dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
        if ( dd > 0.0f ) {
      dd = 1.0f / sqrt(dd);
      n[0] *= dd;
      n[1] *= dd;
      n[2] *= dd;
        }

        is0 = is1 = is2 = 0;
        if ( mesh->extra->iv ) {
          if ( pt->v[0] <= mesh->nvn )
            is0 = mesh->extra->nv[pt->v[0]];
          if ( pt->v[1] <= mesh->nvn )
            is1 = mesh->extra->nv[pt->v[1]];
          if ( pt->v[2] <= mesh->nvn )
            is2 = mesh->extra->nv[pt->v[2]];
        }
        if ( !is0 && pt->v[0] <= mesh->extra->it )
          is0 = mesh->extra->nt[3*(k-1)+1];
        if ( !is1 && pt->v[1] <= mesh->extra->it )  
          is1 = mesh->extra->nt[3*(k-1)+2];
        if ( !is2 && pt->v[2] <= mesh->extra->it )
          is2 = mesh->extra->nt[3*(k-1)+3];

        if ( sc->shrink < 1.0 ) {
          cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.;
          cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.;
          cz = (p0->c[2] + p1->c[2] + p2->c[2]) / 3.;
          t.a[0] = sc->shrink*(p0->c[0]-cx)+cx;
          t.a[1] = sc->shrink*(p0->c[1]-cy)+cy;
          t.a[2] = sc->shrink*(p0->c[2]-cz)+cz;
          t.b[0] = sc->shrink*(p1->c[0]-cx)+cx;
          t.b[1] = sc->shrink*(p1->c[1]-cy)+cy;
          t.b[2] = sc->shrink*(p1->c[2]-cz)+cz;
          t.c[0] = sc->shrink*(p2->c[0]-cx)+cx;
          t.c[1] = sc->shrink*(p2->c[1]-cy)+cy;
          t.c[2] = sc->shrink*(p2->c[2]-cz)+cz;
        }
        else {
          t.a[0] = p0->c[0];
          t.a[1] = p0->c[1];
          t.a[2] = p0->c[2];
          t.b[0] = p1->c[0];
          t.b[1] = p1->c[1];
          t.b[2] = p1->c[2];
          t.c[0] = p2->c[0];
          t.c[1] = p2->c[1];
          t.c[2] = p2->c[2];
        }
        if ( !is0 )
          memcpy(t.na,n,3*sizeof(float));
        else {
          t.na[0] = mesh->extra->n[3*(is0-1)+1];
          t.na[1] = mesh->extra->n[3*(is0-1)+2];
          t.na[2] = mesh->extra->n[3*(is0-1)+3];
        }
        if ( !is1 )
          memcpy(t.nb,n,3*sizeof(float));
        else {
          t.nb[0] = mesh->extra->n[3*(is1-1)+1];
          t.nb[1] = mesh->extra->n[3*(is1-1)+2];
          t.nb[2] = mesh->extra->n[3*(is1-1)+3];
        }
        if ( !is2 )
          memcpy(t.nc,n,3*sizeof(float));
        else {
          t.nc[0] = mesh->extra->n[3*(is2-1)+1];
          t.nc[1] = mesh->extra->n[3*(is2-1)+2];
          t.nc[2] = mesh->extra->n[3*(is2-1)+3];
        }
        if ( mesh->typage == 2 ) {
      ps0  = &mesh->sol[pt->v[0]];
      ps1  = &mesh->sol[pt->v[1]];
      ps2  = &mesh->sol[pt->v[2]];
      t.va = ps0->bb;
      t.vb = ps1->bb;
      t.vc = ps2->bb;
        }
        else {
      ps0 = &mesh->sol[k];
      t.va = t.vb = t.vc = ps0->bb;
        }
        cutTriangle(sc,t);
        k = pt->nxt;
      }
      glEnd();
    }
  }
#ifdef IGL
  if(transp)
  {
    glDepthFunc(old_depth_func);
    glDisable(GL_BLEND);
  }
#endif

  glEndList();
  return(dlist);
}
Ejemplo n.º 9
0
/* build lists for iso-surfaces */
GLuint listTriaIso(pScene sc,pMesh mesh) {
  GLuint     dlist = 0;
  pTriangle  pt;
  pPoint     p0,p1;
  pMaterial  pm;
  pSolution  ps0,ps1;
  double     rgb[3];
  float      iso,cx,cy,cz,cc,kc;
  int        m,k,i,l,l1,nc,ncol;
  static double hsv[3]  = { 0.0, 1.0, 0.9 };
  static int    idir[5] = {0,1,2,0,1};

  /* default */
  if ( !mesh->nt || !mesh->nbb || mesh->typage == 1 )  return(0);
  if ( ddebug ) printf("create iso-values map list / TRIA\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);

  /* create display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);

  /* build list */
  glBegin(GL_LINES);
  ncol = NBCOL;
  for (i=0; i<=ncol*(MAXISO-1); i++) {
    if ( i < ncol*(MAXISO-1) ) {
      l   = i / ncol;
      kc  = (i % ncol) / (float)ncol;
      iso = sc->iso.val[l]*(1.0-kc)+sc->iso.val[l+1]*kc;
      hsv[0] = sc->iso.col[l]*(1.0-kc)+sc->iso.col[l+1]*kc;
    }
    else {
      iso    = sc->iso.val[MAXISO-1];
      hsv[0] = sc->iso.col[MAXISO-1];
    }

    hsvrgb(hsv,rgb);
    glColor3dv(rgb);

    for (m=0; m<sc->par.nbmat; m++) {
      pm = &sc->material[m];
      k  = pm->depmat[LTria];
      if ( !k || pm->flag )  continue;

      while ( k != 0 ) {
        pt = &mesh->tria[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }

        /* analyze edges */
        nc = 0;
        cx = cy = cz = 0.0;
        for (l=0; l<3; l++) {
          l1  = idir[l+1];
          p0  = &mesh->point[pt->v[l]];
          p1  = &mesh->point[pt->v[l1]];
          ps0 = &mesh->sol[pt->v[l]];
          ps1 = &mesh->sol[pt->v[l1]];
          if ( (ps0->bb > iso && ps1->bb <= iso) ||
               (ps0->bb < iso && ps1->bb >= iso) ) {
            cc = 0.0;
            if ( fabs(ps1->bb-ps0->bb) > 0.0 )
              cc = (iso-ps0->bb) / (ps1->bb-ps0->bb);
            if ( cc == 0.0 || cc == 1.0 )  continue;
            cx = p0->c[0]+cc*(p1->c[0]-p0->c[0]);
            cy = p0->c[1]+cc*(p1->c[1]-p0->c[1]);
            nc++;
            if ( mesh->dim == 2 )
              glVertex2f(cx,cy);
            else {
              cz = p0->c[2]+cc*(p1->c[2]-p0->c[2]);
              glVertex3f(cx,cy,cz);
            }
          }
          else if ( ps0->bb == iso && ps1->bb == iso ) {
            nc = 2;
            if ( mesh->dim == 2 ) {
              glVertex2f(p0->c[0],p0->c[1]);
              glVertex2f(p1->c[0],p1->c[1]);
              break;
            }
            else {
              glVertex3f(p0->c[0],p0->c[1],p0->c[2]);
              glVertex3f(p1->c[0],p1->c[1],p1->c[2]);
              break;
            }
          }
        }
        if ( nc > 0 && nc != 2 ) {
          if ( mesh->dim ==2 )  glVertex2f(cx,cy);
          else                  glVertex3f(cx,cy,cz);
        }
        k = pt->nxt;
      }
    }
  }
  glEnd();
  glEndList();
  return(dlist);
}
Ejemplo n.º 10
0
int tetraIsoPOVray(pScene sc,pMesh mesh) {
  FILE      *isofil;
  pTetra     pt;
  pPoint     p0,p1;
  pMaterial  pm;
  pSolution  ps0,ps1;
  double     delta;
  float      iso,cx[4],cy[4],cz[4],cc;
  int        m,k,k1,k2,i,l,pos[4],neg[4],nbpos,nbneg,nbnul;
  char      *ptr,data[128];
  static int tn[4] = {0,0,1,1};
  static int tp[4] = {0,1,1,0};

  /* default */
  if ( !mesh->ntet || !mesh->nbb || mesh->typage == 1 )  return(0);
  if ( ddebug ) printf("create isosurfaces POVray\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);
  delta = sc->iso.val[MAXISO-1] - sc->iso.val[0];

  strcpy(data,mesh->name);
  ptr = strstr(data,".mesh");
  if ( ptr )  ptr = '\0';
  strcat(data,".pov"); 
  if ( ddebug )  fprintf(stdout,"  Writing POVRay file %s\n",data);
  isofil = fopen(data,"w");
  if ( !isofil )  return(0);

  for (i=MAXISO-1; i>=0; i--) {
    iso = sc->iso.val[i];

    if ( i == MAXISO-1 )  iso -= 0.001*fabs(iso)/delta;
    else if ( i == 0 )    iso += 0.001*fabs(iso)/delta;

    fprintf(isofil,"\n#declare isosurf%d = mesh {\n",i);

    for (m=0; m<sc->par.nbmat; m++) {
      pm = &sc->material[m];
      k  = pm->depmat[LTets];
      if ( !k || pm->flag )  continue;

      while ( k != 0 ) {
        pt = &mesh->tetra[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }

        /* analyze vertices */
        nbpos = nbneg = nbnul = 0;
        for (l=0; l<4; l++) {
          p0  = &mesh->point[pt->v[l]];
          ps0 = &mesh->sol[pt->v[l]];
          
          if ( ps0->bb > iso )      pos[nbpos++] = l;
          else if ( ps0->bb < iso ) neg[nbneg++] = l;
          else                      nbnul++;
        }
        if ( nbneg == 4 || nbpos == 4 ) {
          k = pt->nxt;
          continue;
        }

        if ( nbneg == 2 && nbpos == 2 ) {
          for (l=0; l<4; l++) {
            k1  = neg[tn[l]];
            k2  = pos[tp[l]];
            p0  = &mesh->point[pt->v[k1]];
            p1  = &mesh->point[pt->v[k2]];
            ps0 = &mesh->sol[pt->v[k1]];
            ps1 = &mesh->sol[pt->v[k2]];
            cc = 0.0f;
            if ( fabs(ps1->bb-ps0->bb) > 0.0f )
              cc = (iso-ps0->bb) / (ps1->bb-ps0->bb);
            cx[l] = p0->c[0]+cc*(p1->c[0]-p0->c[0]);
            cy[l] = p0->c[1]+cc*(p1->c[1]-p0->c[1]);
            cz[l] = p0->c[2]+cc*(p1->c[2]-p0->c[2]);
          }

	  fprintf(isofil,"triangle {\n");
	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[0]+mesh->xtra,cy[0]+mesh->ytra,cz[0]+mesh->ztra);
 	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[1]+mesh->xtra,cy[1]+mesh->ytra,cz[1]+mesh->ztra);
	  fprintf(isofil,"  <%f,%f,%f>\n" ,
	  cx[2]+mesh->xtra,cy[2]+mesh->ytra,cz[2]+mesh->ztra);
          fprintf(isofil,"}\n");

	  fprintf(isofil,"triangle {\n");
	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[0]+mesh->xtra,cy[0]+mesh->ytra,cz[0]+mesh->ztra);
 	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[2]+mesh->xtra,cy[2]+mesh->ytra,cz[2]+mesh->ztra);
	  fprintf(isofil,"  <%f,%f,%f>\n" ,
	  cx[3]+mesh->xtra,cy[3]+mesh->ytra,cz[3]+mesh->ztra);
          fprintf(isofil,"}\n");
        }
        else if ( !nbnul ) {
          for (l=0; l<3; l++) {
            k1 = nbneg == 3 ? neg[l] : pos[l];
            k2 = nbneg == 3 ? pos[0] : neg[0];
            p0 = &mesh->point[pt->v[k1]];
            p1 = &mesh->point[pt->v[k2]];
            ps0 = &mesh->sol[pt->v[k1]];
            ps1 = &mesh->sol[pt->v[k2]];
            cc = 0.0f;
            if ( fabs(ps1->bb-ps0->bb) > 0.0f ) 
              cc = (iso-ps0->bb) / (ps1->bb-ps0->bb);
            cx[l] = p0->c[0]+cc*(p1->c[0]-p0->c[0]);
            cy[l] = p0->c[1]+cc*(p1->c[1]-p0->c[1]);
            cz[l] = p0->c[2]+cc*(p1->c[2]-p0->c[2]);
          }
	  fprintf(isofil,"triangle {\n");
	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[0]+mesh->xtra,cy[0]+mesh->ytra,cz[0]+mesh->ztra);
 	  fprintf(isofil,"  <%f,%f,%f>,\n",
	  cx[1]+mesh->xtra,cy[1]+mesh->ytra,cz[1]+mesh->ztra);
	  fprintf(isofil,"  <%f,%f,%f>\n",
	  cx[2]+mesh->xtra,cy[2]+mesh->ytra,cz[2]+mesh->ztra);
          fprintf(isofil,"}\n");
        }
        k = pt->nxt;
      }
    }
    fprintf(isofil,"}\n");
  }

  fclose(isofil);
  return(1);
}
Ejemplo n.º 11
0
/* build lists for iso-surfaces */
GLuint listTetraIso(pScene sc,pMesh mesh) {
  FILE      *outv,*outf;
  GLuint     dlist = 0;
  pTetra     pt;
  pPoint     p0,p1;
  pMaterial  pm;
  pSolution  ps0,ps1;
  double     delta,rgb[4],d,ax,ay,az,bx,by,bz;
  float      iso,n[3],cx[4],cy[4],cz[4],cc;
  int        m,k,k1,k2,i,l,pos[4],neg[4],nbpos,nbneg,nbnul,nv,nf;
  static double hsv[3]   = { 0.0f, 1.0f, 0.80f };
  static int tn[4] = {0,0,1,1};
  static int tp[4] = {0,1,1,0};

  /* default */
  if ( !mesh->ntet || !mesh->nbb || mesh->typage == 1 )  return(0);
  if ( ddebug ) printf("create iso-values map list / TETRA\n");
  if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) )  return(0);
  delta = sc->iso.val[MAXISO-1] - sc->iso.val[0];

  /* build display list */
  dlist = glGenLists(1);
  glNewList(dlist,GL_COMPILE);
  if ( glGetError() )  return(0);

  /* build list */
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  glDepthMask(GL_FALSE);

  if (ddebug) {
	outv = fopen("vertex.mesh","w");
	fprintf(outv,"MeshVersionFormatted 1\n Dimension\n 3\n\nVertices\n \n");
	outf = fopen("faces.mesh2","w");
	fprintf(outv,"Triangles\n \n");
  }
  nv = nf = 0;

  glBegin(GL_TRIANGLES);
  for (i=MAXISO-1; i>=0; i--) {
    iso = sc->iso.val[i];

    /* base color */
    /*hsv[0] = 240.0f*(1.0f - (iso-sc->iso.val[0])/delta);*/
    hsv[0] = sc->iso.col[i];
    hsvrgb(hsv,rgb);
    rgb[0] = min(1.0,rgb[0]+BASETR);
    rgb[1] = min(1.0,rgb[1]+BASETR);
    rgb[2] = min(1.0,rgb[2]+BASETR);
    rgb[3] = BASETR + (float)(i-1)/(float)MAXISO*(1.0-BASETR);
    /*rgb[3] = 0.5; */  
    glColor4dv(rgb);

    if ( i == MAXISO-1 )  iso -= 0.001*fabs(iso)/delta;
    else if ( i == 0 )    iso += 0.001*fabs(iso)/delta;

    for (m=0; m<sc->par.nbmat; m++) {
      pm = &sc->material[m];
      k  = pm->depmat[LTets];
      if ( !k || pm->flag )  continue;

      while ( k != 0 ) {
        pt = &mesh->tetra[k];
        if ( !pt->v[0] ) {
          k = pt->nxt;
          continue;
        }

        /* analyze vertices */
        nbpos = nbneg = nbnul = 0;
        for (l=0; l<4; l++) {
          p0  = &mesh->point[pt->v[l]];
          ps0 = &mesh->sol[pt->v[l]];
          /*if ( ps0->bb < sc->iso.val[0] )  ps0->bb = sc->iso.val[0];*/
          
          if ( ps0->bb > iso )      pos[nbpos++] = l;
          else if ( ps0->bb < iso ) neg[nbneg++] = l;
          else                      nbnul++;
        }
        if ( nbneg == 4 || nbpos == 4 ) {
          k = pt->nxt;
          continue;
        }

        if ( nbneg == 2 && nbpos == 2 ) {
          for (l=0; l<4; l++) {
            k1  = neg[tn[l]];
            k2  = pos[tp[l]];
            p0  = &mesh->point[pt->v[k1]];
            p1  = &mesh->point[pt->v[k2]];
            ps0 = &mesh->sol[pt->v[k1]];
            ps1 = &mesh->sol[pt->v[k2]];
            cc = 0.0f;
            if ( fabs(ps1->bb-ps0->bb) > 0.0f )
              cc = (iso-ps0->bb) / (ps1->bb-ps0->bb);
            cx[l] = p0->c[0]+cc*(p1->c[0]-p0->c[0]);
            cy[l] = p0->c[1]+cc*(p1->c[1]-p0->c[1]);
            cz[l] = p0->c[2]+cc*(p1->c[2]-p0->c[2]);
          }

          /* compute face normal */
          ax = cx[1]-cx[0]; ay = cy[1]-cy[0]; az = cz[1]-cz[0];
          bx = cx[2]-cx[0]; by = cy[2]-cy[0]; bz = cz[2]-cz[0];
          n[0] = ay*bz - az*by;
          n[1] = az*bx - ax*bz;
          n[2] = ax*by - ay*bx;
          d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
          if ( d > 0.0f ) {
            d = 1.0f / sqrt(d);
            n[0] *= d;  
            n[1] *= d;  
            n[2] *= d;
          }
          glNormal3fv(n);
          glVertex3f(cx[0],cy[0],cz[0]);
          glVertex3f(cx[1],cy[1],cz[1]);
          glVertex3f(cx[2],cy[2],cz[2]);
          
	      glNormal3fv(n);
          glVertex3f(cx[0],cy[0],cz[0]);
          glVertex3f(cx[2],cy[2],cz[2]);
          glVertex3f(cx[3],cy[3],cz[3]);

          if ( ddebug ) {
            fprintf(outv,"%f %f %f 0\n",cx[0],cy[0],cz[0]);
            fprintf(outv,"%f %f %f 0\n",cx[1],cy[1],cz[1]);
            fprintf(outv,"%f %f %f 0\n",cx[2],cy[2],cz[2]);
            fprintf(outv,"%f %f %f 0\n",cx[3],cy[3],cz[3]);

            fprintf(outf,"%d %d %d 0\n",nv+1,nv+2,nv+3);
            fprintf(outf,"%d %d %d 0\n",nv+1,nv+3,nv+4);
          }
          nv+= 4;
          nf+= 2;
        }
        else if ( !nbnul ) {
          for (l=0; l<3; l++) {
            k1 = nbneg == 3 ? neg[l] : pos[l];
            k2 = nbneg == 3 ? pos[0] : neg[0];
            p0 = &mesh->point[pt->v[k1]];
            p1 = &mesh->point[pt->v[k2]];
            ps0 = &mesh->sol[pt->v[k1]];
            ps1 = &mesh->sol[pt->v[k2]];
            cc = 0.0f;
            if ( fabs(ps1->bb-ps0->bb) > 0.0f ) 
              cc = (iso-ps0->bb) / (ps1->bb-ps0->bb);
            cx[l] = p0->c[0]+cc*(p1->c[0]-p0->c[0]);
            cy[l] = p0->c[1]+cc*(p1->c[1]-p0->c[1]);
            cz[l] = p0->c[2]+cc*(p1->c[2]-p0->c[2]);
          }
          /* compute face normal */
          ax = cx[1]-cx[0]; ay = cy[1]-cy[0]; az = cz[1]-cz[0];
          bx = cx[2]-cx[0]; by = cy[2]-cy[0]; bz = cz[2]-cz[0];
          n[0] = ay*bz - az*by;
          n[1] = az*bx - ax*bz;
          n[2] = ax*by - ay*bx;
          d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
          if ( d > 0.0f ) {
            d = 1.0f / sqrt(d);
            n[0] *= d;
            n[1] *= d;
            n[2] *= d;
          }
          glNormal3fv(n);
          glVertex3f(cx[0],cy[0],cz[0]);
          glVertex3f(cx[1],cy[1],cz[1]);
          glVertex3f(cx[2],cy[2],cz[2]);

          if ( ddebug ) {
            fprintf(outv,"%f %f %f 0\n",cx[0],cy[0],cz[0]);
            fprintf(outv,"%f %f %f 0\n",cx[1],cy[1],cz[1]);
            fprintf(outv,"%f %f %f 0\n",cx[2],cy[2],cz[2]);
            fprintf(outf,"%d %d %d 0\n",nv+1,nv+2,nv+3);
          }
          nv += 3;
          nf += 1;
        }
        k = pt->nxt;
      }
    }
  }
  glEnd();
  glDepthMask(GL_TRUE);
  glDisable(GL_BLEND);

  if ( ddebug ) {
    fclose(outv);
    fclose(outf);
  }
  printf("  Vertices %d   Triangles %d\n",nv,nf);
  glEndList();
  return(dlist);
}