---

nurbsSub.h

/*=============================================================================
        File: nurbsSub.h
     Purpose:       
    Revision: $Id: nurbsSub.h,v 1.3 2003/01/13 19:42:15 philosophil Exp $
  Created by: Philippe Lavoie          (20 January, 1999)
 Modified by: 

 Copyright notice:
          Copyright (C) 1999 Philippe Lavoie
 
          This library is free software; you can redistribute it and/or
          modify it under the terms of the GNU Library General Public
          License as published by the Free Software Foundation; either
          version 2 of the License, or (at your option) any later version.
 
          This library is distributed in the hope that it will be useful,
          but WITHOUT ANY WARRANTY; without even the implied warranty of
          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
          Library General Public License for more details.
 
          You should have received a copy of the GNU Library General Public
          License along with this library; if not, write to the Free
          Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
=============================================================================*/

#ifndef _NURBS_SURFACE_SUBDIVISION_
#define _NURBS_SURFACE_SUBDIVISION_

#include "nurbs.h"
#include "nurbsS.h"
#include <vector>
#include <iostream>

namespace PLib {
  
  template <class T>
    struct SurfSample {
      Point_nD<T,3> point ; 
      Point_nD<T,3> normal ; 
      T normLen ; 
      T u,v ; 

      SurfSample<T>& operator=(const SurfSample<T>& s) ;

      SurfSample() : normLen(-1),u(0),v(0) {;}

      static T epsilon ;
    };



  template <class T>
    class RenderMesh {
    public:
      //virtual ~RenderMesh() = 0 ; 
      virtual void drawHeader() = 0;
      virtual void drawTriangle(const SurfSample<T>&, const SurfSample<T>&, const SurfSample<T>&) = 0;
      virtual void drawFooter() = 0;
      virtual void screenProject(const HPoint_nD<T,3> &worldPt, Point_nD<T,3> &screenPt ) = 0 ; 
    };


  template <class T> class NurbSurface ;

  template <class T>
    struct NurbsSubSurface  {
    public:
      NurbsSubSurface(const NurbsSurface<T,3>& s) ;
      ~NurbsSubSurface() ;

      void drawSubdivisionPS(ostream& os, T tolerance) ;
      void drawSubdivisionPS(const char* f, T tolerance) ;

      void drawSubdivisionVRML(ostream& os, T tolerance, const Color& col=Color(0,0,255)) ;
      void drawSubdivisionVRML(const char* f, T tolerance, const Color& col=Color(0,0,255)) ;

      void drawSubdivisionVRML97(ostream& os, T tolerance, const Color& col=Color(0,0,255)) ;
      void drawSubdivisionVRML97(const char* f, T tolerance, const Color& col=Color(0,0,255)) ;

      //void drawSubdivisionPoints(deque<Point_nD<T,3> > &pnts, T tolerance) ;
      void drawSubdivisionPoints(BasicArray<Point_nD<T,3> > &pnts, T tolerance) ;
      void drawSubdivisionPoints(T tolerance) ;

    protected:

      void drawSubdivision(T tolerance) ;
      void initSurf() ;
      RenderMesh<T> *render;
      const NurbsSurface<T,3> &rsurf ; 
      NurbSurface<T> *surf ;
   };
  

  template <class T>
    class RenderMeshPS : public RenderMesh<T> {
    public:
      RenderMeshPS(ostream& os): out(os) {;}
      virtual ~RenderMeshPS() {;}
      virtual void drawHeader() ;
      virtual void drawTriangle( const SurfSample<T> &v0, const SurfSample<T> &v1, const SurfSample<T> & v2 );
      void drawLine( const SurfSample<T> &v0, const SurfSample<T> &v1);
      virtual void drawFooter() ;
      virtual void screenProject(const HPoint_nD<T,3> &worldPt, Point_nD<T,3> &screenPt ) ; 
    protected:
      ostream& out ;
    };


  //typedef deque<int> IndexSetVector ;

  template <class T>
    class RenderMeshVRML : public RenderMesh<T> {
    public:
      RenderMeshVRML(ostream& os,const Color& col): out(os), color(col) {;}
      virtual ~RenderMeshVRML() { ; }
      virtual void drawHeader() ;
      virtual void drawTriangle( const SurfSample<T> &v0, const SurfSample<T> &v1, const SurfSample<T> & v2 );
      virtual void drawFooter() ;
      virtual void screenProject(const HPoint_nD<T,3> &worldPt, Point_nD<T,3> &screenPt ) ; 
    protected:
      int size ;
      ostream &out ;
      Color color ; 
    };

  template <class T>
    class RenderMeshVRML97 : public RenderMesh<T> {
    public:
      RenderMeshVRML97(ostream& os,const Color& col): out(os), color(col) { init = 1 ;}
      virtual ~RenderMeshVRML97() { ; }
      virtual void drawHeader() ;
      virtual void drawTriangle( const SurfSample<T> &v0, const SurfSample<T> &v1, const SurfSample<T> & v2 );
      virtual void drawFooter() ;
      virtual void screenProject(const HPoint_nD<T,3> &worldPt, Point_nD<T,3> &screenPt ) ; 
    protected:
      int size ;
      ostream &out ;
      Color color ; 
      Point_nD<T,3> p_min,p_max ; 
      int init ;
    };

  template <class T>
    class RenderMeshPoints : public RenderMesh<T> {
    public:
      //RenderMeshPoints(deque<Point_nD<T,3> >& pts): points(pts) {;}
      RenderMeshPoints(BasicArray<Point_nD<T,3> >& pts): points(pts) {;}
      virtual ~RenderMeshPoints() {; }
      virtual void drawHeader() ;
      virtual void drawTriangle( const SurfSample<T> &v0, const SurfSample<T> &v1, const SurfSample<T> & v2 );
      virtual void drawFooter() ;
      virtual void screenProject(const HPoint_nD<T,3> &worldPt, Point_nD<T,3> &screenPt ) ; 
    protected:
      //deque<Point_nD<T,3> > &points ;
      //vector<Point_nD<T,3> > &points ;
      BasicArray<Point_nD<T,3> > &points;
    };


  

} // end namespace


#endif

---