Skip to content
Snippets Groups Projects
Select Git revision
  • 7a4ed01e0b456b1d8574f0205b867d3b726fb0a6
  • master default
  • cgnsUnstructured
  • partitioning
  • poppler
  • HighOrderBLCurving
  • gmsh_3_0_4
  • gmsh_3_0_3
  • gmsh_3_0_2
  • gmsh_3_0_1
  • gmsh_3_0_0
  • gmsh_2_16_0
  • gmsh_2_15_0
  • gmsh_2_14_1
  • gmsh_2_14_0
  • gmsh_2_13_2
  • gmsh_2_13_1
  • gmsh_2_12_0
  • gmsh_2_11_0
  • gmsh_2_10_1
  • gmsh_2_10_0
  • gmsh_2_9_3
  • gmsh_2_9_2
  • gmsh_2_9_1
  • gmsh_2_9_0
  • gmsh_2_8_6
26 results

Widgets.cpp

Blame
  • Forked from gmsh / gmsh
    Source project has a limited visibility.
    Iso.cpp 10.07 KiB
    // $Id: Iso.cpp,v 1.5 2001-01-19 22:32:31 remacle Exp $
    
    #include "Gmsh.h"
    #include "Mesh.h"
    #include "Draw.h"
    #include "Numeric.h"
    
    void RaiseFill(int i, double Val, double ValMin, double Raise[3][5]);
    
    /* ------------------------------------------------------------------------ */
    /*  I n t e r p o l a t e                                                   */
    /* ------------------------------------------------------------------------ */
    
    void Interpolate(double *X, double *Y, double *Z, 
                     double *Val, double V, int I1, int I2, 
                     double *XI, double *YI ,double *ZI){
      
      if(Val[I1] == Val[I2]){
        *XI = X[I1]; 
        *YI = Y[I1]; 
        *ZI = Z[I1]; 
      }
      else{
        *XI= (V - Val[I1])*(X[I2]-X[I1])/(Val[I2]-Val[I1]) + X[I1];
        *YI= (V - Val[I1])*(Y[I2]-Y[I1])/(Val[I2]-Val[I1]) + Y[I1];
        *ZI= (V - Val[I1])*(Z[I2]-Z[I1])/(Val[I2]-Val[I1]) + Z[I1];
      }
    }
    
    /* ------------------------------------------------------------------------ */
    /*  S i m p l e x                                                           */
    /* ------------------------------------------------------------------------ */
    
    void IsoSimplex(double *X, double *Y, double *Z, double *Val, 
                    double V, double Vmin, double Vmax, 
                    double *Offset, double Raise[3][5], int shade){
      int    nb,i;
      double Xp[6],Yp[6],Zp[6];
      double Xpi[6],Ypi[6],Zpi[6];
    
      if(V != Vmax){
        nb = 0;
        if((Val[0] > V && Val[1] <= V) || (Val[1] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,1,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[0] > V && Val[2] <= V) || (Val[2] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,2,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[0] > V && Val[3] <= V) || (Val[3] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[1] > V && Val[2] <= V) || (Val[2] > V && Val[1] <= V)){
          Interpolate(X,Y,Z,Val,V,1,2,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[1] > V && Val[3] <= V) || (Val[3] > V && Val[1] <= V)){
          Interpolate(X,Y,Z,Val,V,1,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[2] > V && Val[3] <= V) || (Val[3] > V && Val[2] <= V)){
          Interpolate(X,Y,Z,Val,V,2,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
      }
      else{
        nb=0;
        if((Val[0] < V && Val[1] <= V) || (Val[1] < V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,1,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[0] < V && Val[2] <= V) || (Val[2] < V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,2,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[0] < V && Val[3] <= V) || (Val[3] < V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[1] < V && Val[2] <= V) || (Val[2] < V && Val[1] <= V)){
          Interpolate(X,Y,Z,Val,V,1,2,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[1] < V && Val[3] <= V) || (Val[3] < V && Val[1] <= V)){
          Interpolate(X,Y,Z,Val,V,1,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
        if((Val[2] < V && Val[3] <= V) || (Val[3] < V && Val[2] <= V)){
          Interpolate(X,Y,Z,Val,V,2,3,&Xp[nb],&Yp[nb],&Zp[nb]); nb++;
        }
      }
    
      /*
        for having a nice isosurface, we should have n . grad v > 0
        n = normal to the polygon
        v = unknown field we wanna draw
       */
    
      if(nb > 2)
        {
          double v1[3] = {Xp[2]-Xp[0],Yp[2]-Yp[0],Zp[2]-Zp[0]};
          double v2[3] = {Xp[1]-Xp[0],Yp[1]-Yp[0],Zp[1]-Zp[0]};
          double n[3];
          prodve(v1,v2,n);
          //test 
    
          // now get the gradient (simplified version of course)
          
          double xx = 0.0;
          if(Val[2] != Val[1])
    	{
    	  double gr[3] = {X[2]-X[1],Y[2]-Y[1],Z[2]-Z[1]};
    	  double xx = gr[0] * n[0] + gr[1] * n[1] + gr[2] + n[2];
    	  if(Val[2] > Val[1]) xx = -xx;
    	}
          if(Val[2] != Val[0])
    	{
    	  double gr[3] = {X[2]-X[0],Y[2]-Y[0],Z[2]-Z[0]};
    	  double xx = gr[0] * n[0] + gr[1] * n[1] + gr[2] + n[2];
    	  if(Val[2] > Val[0]) xx = -xx;
    	}
    
          
    
          if(xx > 0)
    	{
    	  for(i=0;i<nb;i++)
    	    {
    	      Xpi[i] = Xp[i];
    	      Ypi[i] = Yp[i];
    	      Zpi[i] = Zp[i];
    	    }
    	  for(i=0;i<nb;i++)
    	    {
    	      Xp[i] = Xpi[nb-i-1];
    	      Yp[i] = Ypi[nb-i-1];
    	      Zp[i] = Zpi[nb-i-1];
    	    }
    	}
        }
    
    
    
      if(nb == 3) 
        Draw_Triangle(Xp,Yp,Zp,Offset,Raise,shade);
      else if(nb == 4)
        Draw_Quadrangle(Xp,Yp,Zp,Offset,Raise,shade);
    
    }
    
    /* ------------------------------------------------------------------------ */
    /*  T r i a n g l e                                                         */
    /* ------------------------------------------------------------------------ */
    
    void CutTriangle1D(double *X, double *Y, double *Z, double *Val, 
                       double V, double Vmin, double Vmax,
                       double *Xp, double *Yp, double *Zp, int *nb){
      
      if(V != Vmax){
        *nb = 0;
        if((Val[0] > V && Val[1] <= V) || (Val[1] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,1,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }
        if((Val[0] > V && Val[2] <= V) || (Val[2] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }
        if((Val[1] > V && Val[2] <= V) || (Val[2] > V && Val[1] <= V)){
          Interpolate(X,Y,Z,Val,V,1,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }
      }
      else{
        *nb = 0;
        if((Val[0] < V && Val[1] >= V) || (Val[1] < V && Val[0] >= V)){
          Interpolate(X,Y,Z,Val,V,0,1,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }
        if((Val[0] < V && Val[2] >= V) || (Val[2] < V && Val[0] >= V)){
          Interpolate(X,Y,Z,Val,V,0,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }       
        if((Val[1] < V && Val[2] >= V) || (Val[2] < V && Val[1] >= V)){
          Interpolate(X,Y,Z,Val,V,1,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
        }
      }
    
    }
    
    void CutTriangle2D(double *X, double *Y, double *Z, double *Val, 
                       double V1, double V2, double Vmin, double Vmax,
                       double *Xp2, double *Yp2, double *Zp2, int *Np2, double *Vp2){
    
      int     i, io[3],j,iot,Np,Fl;
      double  Xp[5],Yp[5],Zp[5],Vp[5];
    
      *Np2 = 0;
    
      for(i=0;i<3;i++) io[i] = i;
    
      for(i=0;i<2;i++){
        for(j=i+1;j<3;j++){
          if(Val[io[i]]>Val[io[j]]){
            iot = io[i];
            io[i] = io[j];
            io[j] = iot;
          }
        }
      }
    
      /* io[] contient un indexage des noeuds t.q. Val[io[i]] > Val[io[j]] si i > j */
    
      if(Val[io[0]] > V2) return;
      if(Val[io[2]] < V1) return;
    
      if(V1 <= Val[io[0]] && Val[io[2]] <= V2){
        memcpy(Vp2,Val,3*sizeof(double));
        memcpy(Xp2,X,3*sizeof(double)); 
        memcpy(Yp2,Y,3*sizeof(double)); 
        memcpy(Zp2,Z,3*sizeof(double)); 
        *Np2 = 3;
        return;
      }
    
      Np = 0;
      if(V1<=Val[io[0]]){
        Vp[Np] = Val[io[0]];
        Xp[Np] = X[io[0]]; 
        Yp[Np] = Y[io[0]]; 
        Zp[Np] = Z[io[0]]; 
        Np++; Fl = 1;
      }
      else if(Val[io[0]] < V1 && V1 <= Val[io[1]]){
        Vp[Np] = V1;
        Interpolate(X,Y,Z,Val,V1,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; 
        Vp[Np] = V1;
        Interpolate(X,Y,Z,Val,V1,io[0],io[1],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; Fl = 1;
      }
      else {
        Vp[Np] = V1;
        Interpolate(X,Y,Z,Val,V1,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
        Vp[Np] = V1;
        Interpolate(X,Y,Z,Val,V1,io[1],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; Fl = 0;
      }    
    
      if(V2 == Val[io[0]]){
        return;
      }
      else if((Val[io[0]]<V2) && ( V2 < Val[io[1]])){
        Vp[Np] = V2;
        Interpolate(X,Y,Z,Val,V2,io[0],io[1],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
        Vp[Np] = V2;
        Interpolate(X,Y,Z,Val,V2,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
      }
      else if(V2 < Val[io[2]]){
        if(Fl){
          Vp[Np] = Val[io[1]];
          Xp[Np] = X[io[1]]; 
          Yp[Np] = Y[io[1]]; 
          Zp[Np] = Z[io[1]];
          Np++;
        }
        Vp[Np] = V2;
        Interpolate(X,Y,Z,Val,V2,io[1],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
        Vp[Np] = V2;
        Interpolate(X,Y,Z,Val,V2,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
      }
      else{
        if(Fl){
          Vp[Np] = Val[io[1]];
          Xp[Np] = X[io[1]];
          Yp[Np] = Y[io[1]]; 
          Zp[Np] = Z[io[1]];
          Np++;
        }
        Vp[Np] = Val[io[2]];
        Xp[Np] = X[io[2]]; 
        Yp[Np] = Y[io[2]]; 
        Zp[Np] = Z[io[2]];
        Np++;
      }
    
      Vp2[0] = Vp[0];
      Xp2[0] = Xp[0]; 
      Yp2[0] = Yp[0]; 
      Zp2[0] = Zp[0]; 
      *Np2 = 1;
    
      for(i=1;i<Np;i++){
        if((Xp[i] != Xp2[(*Np2)-1]) ||(Yp[i] != Yp2[(*Np2)-1]) ||(Zp[i] != Zp2[(*Np2)-1])){      
          Vp2[*Np2] = Vp[i];
          Xp2[*Np2] = Xp[i]; 
          Yp2[*Np2] = Yp[i]; 
          Zp2[*Np2] = Zp[i];
          (*Np2)++;
        }
      }
    
      if(Xp2[0] == Xp2[(*Np2)-1] && Yp2[0] == Yp2[(*Np2)-1] && Zp2[0] == Zp2[(*Np2)-1]){
        (*Np2)-- ;
      }
    
    }
    
    /* ------------------------------------------------------------------------ */
    /*  L i n e                                                                 */
    /* ------------------------------------------------------------------------ */
    
    void CutLine0D(double *X, double *Y, double *Z, double *Val, 
                   double V, double Vmin, double Vmax,
                   double *Xp, double *Yp, double *Zp, int *nb){
      
      *nb = 0;
    
      if(V != Vmax){
        if((Val[0] > V && Val[1] <= V) || (Val[1] > V && Val[0] <= V)){
          Interpolate(X,Y,Z,Val,V,0,1,Xp,Yp,Zp); *nb = 1;
        }
      }
      else{
        if((Val[0] < V && Val[1] >= V) || (Val[1] < V && Val[0] >= V)){
          Interpolate(X,Y,Z,Val,V,0,1,Xp,Yp,Zp); *nb = 1;
        }
      }
    }
    
    void CutLine1D(double *X, double *Y, double *Z, double *Val, 
                   double V1, double V2, double Vmin, double Vmax,
                   double *Xp2, double *Yp2, double *Zp2, int *Np2, double *Vp2){
    
      int io[2];
    
      if(Val[0]<Val[1]){
        io[0] = 0;
        io[1] = 1;
      }
      else{
        io[0] = 1;
        io[1] = 0;
      }
    
      /* io[] contient un indexage des noeuds t.q. Val[io[i]] > Val[io[j]] si i > j */
    
      *Np2 = 0;
    
      if(Val[io[0]] > V2) return;
      if(Val[io[1]] < V1) return;
    
      *Np2 = 2;
    
      if(V1 <= Val[io[0]] && Val[io[1]] <= V2){
        memcpy(Vp2,Val,2*sizeof(double));
        memcpy(Xp2,X,2*sizeof(double)); 
        memcpy(Yp2,Y,2*sizeof(double)); 
        memcpy(Zp2,Z,2*sizeof(double)); 
        return;
      }
    
      if(V1<=Val[io[0]]){
        Vp2[0] = Val[io[0]];
        Xp2[0] = X[io[0]]; 
        Yp2[0] = Y[io[0]]; 
        Zp2[0] = Z[io[0]]; 
      }
      else{
        Vp2[0] = V1;
        Interpolate(X,Y,Z,Val,V1,io[0],io[1],&Xp2[0],&Yp2[0],&Zp2[0]);
      }
    
      if(V2>=Val[io[1]]){
        Vp2[1] = Val[io[1]];
        Xp2[1] = X[io[1]]; 
        Yp2[1] = Y[io[1]]; 
        Zp2[1] = Z[io[1]]; 
      }
      else{
        Vp2[1] = V2;
        Interpolate(X,Y,Z,Val,V2,io[0],io[1],&Xp2[1],&Yp2[1],&Zp2[1]);
      }
    
    }