---

TensorManifold.H

Go to the documentation of this file.

#ifndef _TENSORMANIFOLD_H
#define _TENSORMANIFOLD_H

#include <TensorArray.H>
#include <Model.H>
#include <tensormanifold_type_def.H>
#include <KnotVector.H>

namespace xchen
{
  template<int dims = 2, int sp_dims = 3>
  class TensorManifold : public Model
  {
      friend class glModel;
      def_type_name_for_tensor_manifold(dims, sp_dims);
  public:
      TensorManifold() : rational(false), sbd_initialized(false)                            { }
      TensorManifold(mesh_t const& m) : ctl_msh(m), rational(false), sbd_initialized(false) { }

      TensorManifold(TensorManifold const& rhs, Transform const&);  

      mesh_t& ControlMesh()                                 { return ctl_msh; }
      bool& IsRational()                                    { return rational; }  

      virtual void Subdivide(int depth=1)const = 0;         
      
      friend ostream& operator<< <>(ostream& os, TensorManifold const& m);
      
  protected:
      void GenerateUI();                                    // Hot key 'm' controls whether draw contol mesh or draw approximated manifold.
      void DrawBrief() const;                               // Draw original ctl_mesh when mouse transformation the model.
      void Draw() const;                                    // Either draw subidvided ctl mesh or its approximation to manifold(points not on it not drawn.)
      void draw(mesh_t& mesh) const;                        // call this directly to draw iso manifolds.

      mesh_t ctl_msh;        // defining dat: control mesh.
      int deg[dims];         // defining dat: degrees.
      bool rational;         // defining dat: polynomial or rational type.

      mesh_t sbd_msh;        // subdivision data: subdivided mesh.
      Nmesh_t Nmsh;          // subdivision data: normal mesh is defined for a n-manifold embedding in (n+1)-space. Currently only implemented for n=2.
      mesh_t Dmsh[dims];     // subdivision data: partial derivative along each domain component.
      bool sbd_initialized;  // are sbd data (including in inherited) initialized? reset by clean_sbd(), and set appropriately by Derived class.


      
      enum { bzr_surface, bsp_surface,  sbd_surface } srf_type;
      void set2bzr_srf_type()                { srf_type = bzr_surface; }
      void set2bsp_srf_type()                { srf_type = bsp_surface; }
      void set2sbd_srf_type()                { srf_type = sbd_surface; }

      void init_sbd()                        { sbd_msh = ctl_msh; }  
      void clean_sbd()                       { sbd_msh.Clear(); Nmsh.Clear(); ForEachIofDims Dmsh[i].Clear(); sbd_initialized = false; }
      
  private:
      bool force_draw_vertext_stride_to_1;
      void draw_grid2D(int row_dir, int other_dir, row_iterator itr1) const;                  
      void draw_grid2D(int row_dir, int other_dir, row_iterator v_itr1, row_Niterator n_itr1) const;  // with normals.
      void draw_grid3D(mesh_t&) const;
      void drawNormalInPlace() const;
      void drawNormalSurface() const;
  };

  template<int dims, int sp_dims>
  inline TensorManifold<dims, sp_dims> :: 
  TensorManifold(TensorManifold<dims,sp_dims>const& rhs, Transform const& trans) : ctl_msh(trans * rhs.ctl_msh), rational(rhs.rational), sbd_initialized(false)
  { 
    copy(&(rhs.deg[0]), &(rhs.deg[0]) + dims, deg);
  }


  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: GenerateUI()
  { 
    Model::GenerateUI(); 
    ui->AddboolControl("Draw Polygon Model", 'p', true); 
    ui->AddboolControl("Draw Original Control Mesh", 'm'); 
    ui->AddboolControl("Draw Normal In Place", 'N'); 
    ui->AddboolControl("Draw Normal Surface", 'n'); 
    ui->AddboolControl("Subdivide", 's'); 
  }
  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: DrawBrief() const
  { 
    (bool&)force_draw_vertext_stride_to_1 = true;
    {
      glPushAttrib(GL_POLYGON_BIT | GL_LIGHTING_BIT);
      glDisable(GL_LIGHTING);
      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
      glColor3f(1.0,1.0,1.0);

      draw( (mesh_t&)ctl_msh );

      glPopAttrib();
    }
    (bool&)force_draw_vertext_stride_to_1 = false;
  }
  
  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: Draw() const     
  { 
    if(ui->GetboolControl("Subdivide"))
    {
      Subdivide();
      ui->SetboolControl("Subdivide", false);
    }
        
    if( ui->GetboolControl("Draw Original Control Mesh") ) DrawBrief();

    if(ui->GetboolControl("Draw Polygon Model"))
    {
      if(sbd_msh.Empty())
        DrawBrief();
      else 
      {
        //      drawNormalSurface(); return;
        draw((mesh_t&) sbd_msh );

        if(dims==2 && !Nmsh.Empty())
        {
          if(ui->GetboolControl("Draw Normal In Place"))
            drawNormalInPlace();
          if(ui->GetboolControl("Draw Normal Surface"))
            drawNormalSurface();
        }
      }
    }
  }
  

  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: drawNormalInPlace() const
  {
    row_iterator row_itr = ((mesh_t&)sbd_msh).RowIterate(0);
    linear_Niterator Nitr = ((Nmesh_t&)Nmsh).LinearIterate();
    for(; !row_itr.PastEnd(); row_itr += deg[1])
    {
      for(element_iterator itr = row_itr.Begin(); itr < row_itr.End(); itr += deg[0], ++Nitr)
      {
        //      wglDrawArrowAt(*Nitr, *itr);
      }
    }
  }
  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: drawNormalSurface() const
  {
    glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT);
    glDisable(GL_LIGHTING);
    glColor3f(1,0,0);
    {
      row_Niterator itr1 = ((Nmesh_t&)Nmsh).RowIterate(0);
      for(row_Niterator itr2 = itr1+1; !itr2.PastEnd(); ++itr1, ++itr2)
      {
        element_Niterator itr11 = itr1.Begin();       
        element_Niterator itr22 = itr2.Begin(); 
        glBegin(GL_QUAD_STRIP);
        {
          for(; itr11 < itr1.End(); ++itr11, ++itr22)
          {
            wglVertex(*itr22);
            wglVertex(*itr11);
          }
        }
        glEnd();
      }
    }
    glPopAttrib();
  }
  


  
  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: draw(mesh_t& mesh) const
  {
    {
      switch(dims)
      {
        case 1: 
        {
          glEnableClientState(GL_VERTEX_ARRAY);
          {
            int stride = 1;
            if(!force_draw_vertext_stride_to_1 && (srf_type == bzr_surface || srf_type == bsp_surface) )
              stride = deg[0];
            
            glVertexPointer(sp_dims, GL_DOUBLE, sizeof(point_t) * stride, &mesh[0][0]); 
            glDrawArrays(GL_LINE_STRIP, 0, (mesh.GetSize(0)-1) / stride + 1);
          }
          glDisableClientState(GL_VERTEX_ARRAY); 
          break;
        }
        case 2:
        {
          if(Nmsh.Empty())
            draw_grid2D(0, 1, mesh.RowIterate(0)); 
          else
          {
            glEnable(GL_NORMALIZE);
            draw_grid2D(0, 1, mesh.RowIterate(0), ((Nmesh_t&)Nmsh).RowIterate(0));
            glDisable(GL_NORMALIZE);
          }
          break;
        }
        case 3: 
        {
          draw_grid3D(mesh); break;
        }
        //      default: break;
      }
    }
  }

  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: draw_grid3D(mesh_t& mesh) const
  {
    int sz, start[dims], end[dims];
    mesh.GetSize(end);
    bzero(start, sizeof(int) * dims);

    bool deg_stride = !force_draw_vertext_stride_to_1 && (srf_type == bzr_surface || srf_type == bsp_surface);
    
    sz = end[2];          
    for(int i=0; i<sz; i += (deg_stride? deg[2] : 1) )    //slice i cut across direction 2.
    {
      start[2] = i;
      end[2] = i+1;
      draw_grid2D(0, 1, mesh.RowIterate(0, start, end));
    }
    start[2] = 0;
    end[2] = sz;
        
    sz = end[1];          
    for(int i=0; i<sz; i += (deg_stride? deg[1] : 1))    //slice i cut across direction 1.
    {
      start[1] = i;
      end[1] = i+1;
      draw_grid2D(2, 0, mesh.RowIterate(2, start, end));
    }
    start[1] = 0;
    end[1] = sz;
        
    sz = end[0];          
    for(int i=0; i<sz; i += (deg_stride? deg[0] : 1))    //slice i cut across direction 0.
    {
      start[0] = i;
      end[0] = i+1;
      draw_grid2D(1, 2, mesh.RowIterate(1, start, end));
    }
  }
  
  
  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: draw_grid2D(int row_dir, int other_dir, row_iterator v_itr1, row_Niterator n_itr1) const
  {
    int step1 = 1, step2 = 1;     // row_dir is direction 1, other_direction is direction 2.
    if(!force_draw_vertext_stride_to_1 && (srf_type == bzr_surface || srf_type == bsp_surface))
    {
      step1 = deg[row_dir];
      step2 = deg[other_dir];
    }
    
    row_Niterator n_itr2 = n_itr1+1;
    row_iterator v_itr2 = v_itr1+step2; 
    for(; !v_itr2.PastEnd(); v_itr1 += step2, v_itr2 += step2, ++n_itr1, ++n_itr2)
    {
      element_iterator v_itr11 = v_itr1.Begin();
      element_iterator v_itr22 = v_itr2.Begin(); 
      element_Niterator n_itr11 = n_itr1.Begin();
      element_Niterator n_itr22 = n_itr2.Begin(); 
      glBegin(GL_QUAD_STRIP);
      {
        for(; v_itr11 < v_itr1.End(); v_itr11 += step1, v_itr22 += step1, ++n_itr11, ++n_itr22)
        {
          wglNormal(*n_itr22);
          wglVertex(*v_itr22);
          wglNormal(*n_itr11);
          wglVertex(*v_itr11);
        }
      }
      glEnd();
    }
  }
  

  template<int dims, int sp_dims>
  inline void TensorManifold<dims, sp_dims> :: draw_grid2D(int row_dir, int other_dir, row_iterator itr1) const
  {
    int step1 = 1, step2 = 1;     // row_dir is direction 1, other_direction is direction 2.
    if(!force_draw_vertext_stride_to_1 && (srf_type == bzr_surface || srf_type == bsp_surface))
    {
      step1 = deg[row_dir];
      step2 = deg[other_dir];
    }
    
    for(row_iterator itr2 = itr1+step2; !itr2.PastEnd(); itr1 += step2, itr2 += step2)
    {
      element_iterator itr11 = itr1.Begin();          
      element_iterator itr22 = itr2.Begin(); 
      glBegin(GL_QUAD_STRIP);
      {
        for(; itr11 < itr1.End(); itr11 += step1, itr22 += step1)
        {
          wglVertex(*itr22);
          wglVertex(*itr11);
        }
      }
      glEnd();
    }
  }
  

  template<int dims, int sp_dims>
  ostream& operator<<(ostream& os, TensorManifold<dims, sp_dims> const& m)
  {
    return os << (m.ctl_msh);
  }
  
      
  

}//end namespace xchen


#endif

---