--- matrix/cvector.h.orig	Mon May 13 14:07:45 2002

+++ matrix/cvector.h	Thu Nov 30 23:30:00 2006

@@ -54,10 +54,10 @@

     CVector(const BasicArray<T>& v) : Vector<T>(v), index(0)  {;}

     virtual ~CVector() {}

-    T& operator[](const int i) { return x[i%sze]; }

-    T  operator[](const int i) const   { return x[i%sze]; }

+    T& operator[](const int i) { return this->x[i%this->sze]; }

+    T  operator[](const int i) const   { return this->x[i%this->sze]; }

-    void put(T v) { x[index] = v ; index = (index+1)%sze; }

+    void put(T v) { this->x[index] = v ; index = (index+1)%this->sze; }

   protected:

     int index ;

--- nurbs/d_nurbsSub.cpp.orig	Mon May 13 13:11:57 2002

+++ nurbs/d_nurbsSub.cpp	Fri Dec  1 01:17:36 2006

@@ -14,8 +14,8 @@

   template class RenderMeshPoints<double> ;

-  double NurbSurface<double>::epsilon = 1e-6 ;

-  double SurfSample<double>::epsilon = 1e-6 ;

+  template <> double NurbSurface<double>::epsilon = 1e-6 ;

+  template <> double SurfSample<double>::epsilon = 1e-6 ;

   template void DrawSubdivision( NurbSurface<double> *, double tolerance );

   template void DrawEvaluation( NurbSurface<double> * );

--- nurbs/f_nurbsSub.cpp.orig	Mon May 13 13:11:57 2002

+++ nurbs/f_nurbsSub.cpp	Fri Dec  1 01:15:08 2006

@@ -14,8 +14,8 @@

   template class RenderMeshPoints<float> ;

-  float NurbSurface<float>::epsilon = 1e-6 ;

-  float SurfSample<float>::epsilon = 1e-6 ;

+  template <> float NurbSurface<float>::epsilon = 1e-6 ;

+  template <> float SurfSample<float>::epsilon = 1e-6 ;

   template void DrawSubdivision( NurbSurface<float> *, float tolerance );

   template void DrawEvaluation( NurbSurface<float> * );

--- nurbs/hnurbsS.cpp.orig	Fri May 17 11:24:21 2002

+++ nurbs/hnurbsS.cpp	Fri Dec  1 00:40:08 2006

@@ -103,11 +103,11 @@

   initBase() ;

   offset.resize(baseSurf.ctrlPnts()) ;

-  P = baseSurf.ctrlPnts() ;

-  U = baseSurf.knotU() ;

-  V = baseSurf.knotV() ;

-  degU = baseSurf.degreeU() ;

-  degV = baseSurf.degreeV() ;

+  this->P = baseSurf.ctrlPnts() ;

+  this->U = baseSurf.knotU() ;

+  this->V = baseSurf.knotV() ;

+  this->degU = baseSurf.degreeU() ;

+  this->degV = baseSurf.degreeV() ;

   //updateSurface() ;

@@ -162,11 +162,11 @@

   baseUpdateN = baseLevel_->modifiedN()-1 ; // Set it so that initBase will run

   initBase() ;

   offset.resize(baseSurf.ctrlPnts()) ;

-  P = baseSurf.ctrlPnts() ;

-  U = baseSurf.knotU() ;

-  V = baseSurf.knotV() ;

-  degU = baseSurf.degreeU() ;

-  degV = baseSurf.degreeV() ;

+  this->P = baseSurf.ctrlPnts() ;

+  this->U = baseSurf.knotU() ;

+  this->V = baseSurf.knotV() ;

+  this->degU = baseSurf.degreeU() ;

+  this->degV = baseSurf.degreeV() ;

   //updateSurface() ;

 }

@@ -200,7 +200,7 @@

   rU.resize(0) ;

   rV.resize(0) ;

-  offset = P ;

+  offset = this->P ;

 }

 /*!

@@ -334,11 +334,11 @@

   }

   if(baseLevel_){

     if(initBase()){

-      P = baseSurf.ctrlPnts() ;

-      U = baseSurf.knotU() ;

-      V = baseSurf.knotV() ;

-      degU = baseSurf.degreeU() ;

-      degV = baseSurf.degreeV() ;

+      this->P = baseSurf.ctrlPnts() ;

+      this->U = baseSurf.knotU() ;

+      this->V = baseSurf.knotV() ;

+      this->degU = baseSurf.degreeU() ;

+      this->degV = baseSurf.degreeV() ;

     }

     if(i0>=0 && j0>=0){

       Point_nD<T,N> vecOffset ;

@@ -352,13 +352,13 @@

 	  offset(i0,j0).y()*jvec(i0,j0) +

 	  offset(i0,j0).z()*kvec(i0,j0) ;

       }

-      P(i0,j0).x() = baseSurf.ctrlPnts()(i0,j0).x()+vecOffset.x() ;

-      P(i0,j0).y() = baseSurf.ctrlPnts()(i0,j0).y()+vecOffset.y() ;

-      P(i0,j0).z() = baseSurf.ctrlPnts()(i0,j0).z()+vecOffset.z() ;

+      this->P(i0,j0).x() = baseSurf.ctrlPnts()(i0,j0).x()+vecOffset.x() ;

+      this->P(i0,j0).y() = baseSurf.ctrlPnts()(i0,j0).y()+vecOffset.y() ;

+      this->P(i0,j0).z() = baseSurf.ctrlPnts()(i0,j0).z()+vecOffset.z() ;

     }

     else{

-      for(int i=0;i<P.rows();++i)

-	for(int j=0;j<P.cols();++j){

+      for(int i=0;i<this->P.rows();++i)

+	for(int j=0;j<this->P.cols();++j){

 	  if(offset(i,j).x() != 0 || 

 	     offset(i,j).y() != 0 || offset(i,j).z() || 0){

 	    Point_nD<T,N> vecOffset ;

@@ -372,20 +372,20 @@

 		offset(i,j).y()*jvec(i,j) +

 		offset(i,j).z()*kvec(i,j) ;

 	    }

-	    P(i,j).x() = baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

-	    P(i,j).y() = baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

-	    P(i,j).z() = baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

+	    this->P(i,j).x() = baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

+	    this->P(i,j).y() = baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

+	    this->P(i,j).z() = baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

 	  }

 	}

     }

   }

   else{

     if(i0>=0 && j0>=0)

-      P(i0,j0) = offset(i0,j0) ;

+      this->P(i0,j0) = offset(i0,j0) ;

     else{

-      for(int i=0;i<P.rows();++i)

-	for(int j=0;j<P.cols();++j){

-	  P(i,j) = offset(i,j) ;

+      for(int i=0;i<this->P.rows();++i)

+	for(int j=0;j<this->P.cols();++j){

+	  this->P(i,j) = offset(i,j) ;

 	}

     }

   }

@@ -554,17 +554,17 @@

       return mod ;

   }

-  if(u<knotU()[0] || u>knotU()[knotU().n()-1])

+  if(u<this->knotU()[0] || u>this->knotU()[this->knotU().n()-1])

     return -1 ;

-  if(v<knotV()[0] || v>knotU()[knotV().n()-1])

+  if(v<this->knotV()[0] || v>this->knotU()[this->knotV().n()-1])

     return -1 ;

   int su = findSpanU(u) ;

   int sv = findSpanV(v) ;

-  for(int i=0;i<=degU;++i)

-    for(int j=0;j<=degV;++j){

-      if(offset(su-degU+i,sv+degV+j) != HPoint_nD<T,N>(0,0,0,0))

+  for(int i=0;i<=this->degU;++i)

+    for(int j=0;j<=this->degV;++j){

+      if(offset(su-this->degU+i,sv+this->degV+j) != HPoint_nD<T,N>(0,0,0,0))

 	return level_ ;

     }

@@ -742,16 +742,16 @@

 template <class T, int N>

 void HNurbsSurface<T,N>::splitUV(int nu, int nv, Vector<T> &nU, Vector<T> &nV){

-  nU.resize(knotU().n()*nu) ;

-  nV.resize(knotV().n()*nv) ;

+  nU.resize(this->knotU().n()*nu) ;

+  nV.resize(this->knotV().n()*nv) ;

   int i,j,n ;

   n = 0 ; 

-  for(i=1;i<knotU().n();++i){

-    if(knotU()[i] >knotU()[i-1]){

-      T a = knotU()[i-1] ;

-      T b = knotU()[i] ;

+  for(i=1;i<this->knotU().n();++i){

+    if(this->knotU()[i] >this->knotU()[i-1]){

+      T a = this->knotU()[i-1] ;

+      T b = this->knotU()[i] ;

       for(j=0;j<nu;++j){

@@ -763,10 +763,10 @@

   nU.resize(n) ;

   n = 0 ;

-  for(i=1;i<knotV().n();++i){

-    if(knotV()[i] > knotV()[i-1]){

-      T a = knotV()[i-1] ;

-      T b = knotV()[i] ;

+  for(i=1;i<this->knotV().n();++i){

+    if(this->knotV()[i] > this->knotV()[i-1]){

+      T a = this->knotV()[i-1] ;

+      T b = this->knotV()[i] ;

       for(j=0;j<nv;++j){

 	nV[n] = a + (b-a)*T(j+1)/T(nv+1) ;

@@ -805,22 +805,22 @@

   int i,j,n ;

   if(su<=0)

-    su = degU  ;

+    su = this->degU  ;

   if(sv<=0)

-    sv = degV  ;

-  if(su>degU+1)

-    su = degU+1 ;

-  if(sv>degV+1)

-    sv = degV+1 ;

+    sv = this->degV  ;

+  if(su>this->degU+1)

+    su = this->degU+1 ;

+  if(sv>this->degV+1)

+    sv = this->degV+1 ;

-  nU.resize(knotU().n()*nu*su) ;

-  nV.resize(knotV().n()*nv*sv) ;

+  nU.resize(this->knotU().n()*nu*su) ;

+  nV.resize(this->knotV().n()*nv*sv) ;

   n = 0 ; 

-  for(i=1;i<knotU().n();++i){

-    if(knotU()[i] >knotU()[i-1]){

-      T a = knotU()[i-1] ;

-      T b = knotU()[i] ;

+  for(i=1;i<this->knotU().n();++i){

+    if(this->knotU()[i] >this->knotU()[i-1]){

+      T a = this->knotU()[i-1] ;

+      T b = this->knotU()[i] ;

       for(j=0;j<nu;++j){

@@ -835,10 +835,10 @@

   nU.resize(n) ;

   n = 0 ;

-  for(i=1;i<knotV().n();++i){

-    if(knotV()[i] > knotV()[i-1]){

-      T a = knotV()[i-1] ;

-      T b = knotV()[i] ;

+  for(i=1;i<this->knotV().n();++i){

+    if(this->knotV()[i] > this->knotV()[i-1]){

+      T a = this->knotV()[i-1] ;

+      T b = this->knotV()[i] ;

       for(j=0;j<nv;++j){

 	T v = a + (b-a)*T(j+1)/T(nv+1) ;

@@ -1014,10 +1014,10 @@

     if(!fin.read((char*)&du,sizeof(int))) { delete []type ; return 0 ;}

     if(!fin.read((char*)&dv,sizeof(int))) { delete []type ; return 0 ;}

-    resize(nu,nv,du,dv) ;

+    this->resize(nu,nv,du,dv) ;

-    if(!fin.read((char*)U.memory(),sizeof(T)*U.n())) { delete []type ; return 0 ;}

-    if(!fin.read((char*)V.memory(),sizeof(T)*V.n())) { delete []type ; return 0 ;}

+    if(!fin.read((char*)this->U.memory(),sizeof(T)*this->U.n())) { delete []type ; return 0 ;}

+    if(!fin.read((char*)this->V.memory(),sizeof(T)*this->V.n())) { delete []type ; return 0 ;}

     if(!r1){

       p = new T[3*nu*nv] ;

@@ -1025,10 +1025,10 @@

       p2 = p ;

       for(int i=0;i<nu;i++)

 	for(int j=0;j<nv;j++){

-	  P(i,j).x() = *(p++) ;

-	  P(i,j).y() = *(p++) ;

-	  P(i,j).z() = *(p++) ;

-	  P(i,j).w() = 1.0 ;

+	  this->P(i,j).x() = *(p++) ;

+	  this->P(i,j).y() = *(p++) ;

+	  this->P(i,j).z() = *(p++) ;

+	  this->P(i,j).w() = 1.0 ;

 	}

       delete []p2 ;

     }

@@ -1038,14 +1038,14 @@

       p2 = p ;

       for(int i=0;i<nu;i++)

 	for(int j=0;j<nv;j++){

-	  P(i,j).x() = *(p++) ;

-	  P(i,j).y() = *(p++) ;

-	  P(i,j).z() = *(p++) ;

-	  P(i,j).w() = *(p++) ;

+	  this->P(i,j).x() = *(p++) ;

+	  this->P(i,j).y() = *(p++) ;

+	  this->P(i,j).z() = *(p++) ;

+	  this->P(i,j).w() = *(p++) ;

 	}

       delete []p2 ;

     }

-    offset = P ;

+    offset = this->P ;

     this->updateSurface() ;

   }

   else { // reading the offset information

@@ -1144,29 +1144,29 @@

   if(!fout)

     return 0 ;

   if(!baseLevel_){

-    int prows = P.rows();

-    int pcols = P.cols();

+    int prows = this->P.rows();

+    int pcols = this->P.cols();

     char st = '0' + sizeof(T) ; 

     if(!fout.write((char*)&"hns4",sizeof(char)*4)) return 0 ;

     if(!fout.write((char*)&st,sizeof(char))) return 0 ; 

     if(!fout.write((char*)&prows,sizeof(int))) return 0 ;

     if(!fout.write((char*)&pcols,sizeof(int))) return 0 ;

-    if(!fout.write((char*)&degU,sizeof(int))) return 0 ;

-    if(!fout.write((char*)&degV,sizeof(int))) return 0 ;

-    if(!fout.write((char*)U.memory(),sizeof(T)*U.n())) return 0 ;

-    if(!fout.write((char*)V.memory(),sizeof(T)*V.n())) return 0 ;

+    if(!fout.write((char*)&this->degU,sizeof(int))) return 0 ;

+    if(!fout.write((char*)&this->degV,sizeof(int))) return 0 ;

+    if(!fout.write((char*)this->U.memory(),sizeof(T)*this->U.n())) return 0 ;

+    if(!fout.write((char*)this->V.memory(),sizeof(T)*this->V.n())) return 0 ;

     T *p,*p2 ;

-    p = new T[P.rows()*P.cols()*4] ;

+    p = new T[this->P.rows()*this->P.cols()*4] ;

     p2 = p ;

-    for(int i=0;i<P.rows();i++) 

-      for(int j=0;j<P.cols();j++){

+    for(int i=0;i<this->P.rows();i++) 

+      for(int j=0;j<this->P.cols();j++){

 	*p = offset(i,j).x() ; p++ ;

 	*p = offset(i,j).y() ; p++ ;

 	*p = offset(i,j).z() ; p++ ;

 	*p = offset(i,j).w() ; p++ ;

       }

-    if(!fout.write((char*)p2,sizeof(T)*P.rows()*P.cols()*4)) return 0 ;

+    if(!fout.write((char*)p2,sizeof(T)*this->P.rows()*this->P.cols()*4)) return 0 ;

     delete []p2 ;

   }

   else{

@@ -1282,7 +1282,7 @@

   int i,j ;

   j = 0 ;

   for(i=0;i<X.n();++i){

-    if(X[i]>=U[0] && X[i]<=U[U.n()-1]){

+    if(X[i]>=this->U[0] && X[i]<=this->U[this->U.n()-1]){

       Xu[j] = X[i] ;

       ++j ;

     }

@@ -1294,7 +1294,7 @@

       nextLevel_->refineKnotU(Xu) ;

     }

-    NurbsSurface<T,N> osurf(degU,degV,U,V,offset) ;

+    NurbsSurface<T,N> osurf(this->degU,this->degV,this->U,this->V,offset) ;

     osurf.refineKnotU(Xu) ;

@@ -1324,7 +1324,7 @@

   int i,j ;

   j = 0 ;

   for(i=0;i<X.n();++i){

-    if(X[i]>=V[0] && X[i]<=V[V.n()-1]){

+    if(X[i]>=this->V[0] && X[i]<=this->V[this->V.n()-1]){

       Xv[j] = X[i] ;

       ++j ;

     }

@@ -1336,7 +1336,7 @@

       nextLevel_->refineKnotV(Xv) ;

     }

-    NurbsSurface<T,N> osurf(degU,degV,U,V,offset) ;

+    NurbsSurface<T,N> osurf(this->degU,this->degV,this->U,this->V,offset) ;

     osurf.refineKnotV(Xv) ;

@@ -1370,26 +1370,26 @@

 */

 template <class T, int N>

 int HNurbsSurface<T,N>::movePointOffset(T u, T v, const Point_nD<T,N>& delta){

-  P = offset ; 

+  this->P = offset ; 

   // by definition the offset has w = 0 , but this isn't valid for

   // the control points, increasing the w by 1, will generate a valid surface

   if(baseLevel_)

-    for(int i=0;i<P.rows();++i)

-      for(int j=0;j<P.cols();++j){

-	P(i,j).w() += T(1) ; 

+    for(int i=0;i<this->P.rows();++i)

+      for(int j=0;j<this->P.cols();++j){

+	this->P(i,j).w() += T(1) ; 

       }

   if(NurbsSurface<T,N>::movePoint(u,v,delta)){

-    offset = P ;

+    offset = this->P ;

     // need to reset the offset weights

     if(baseLevel_)

-      for(int i=0;i<P.rows();++i)

-	for(int j=0;j<P.cols();++j){

-	  P(i,j).w() -= T(1) ; 

+      for(int i=0;i<this->P.rows();++i)

+	for(int j=0;j<this->P.cols();++j){

+	  this->P(i,j).w() -= T(1) ; 

       }

-    P = baseSurf.ctrlPnts() ; 

+    this->P = baseSurf.ctrlPnts() ; 

     updateSurface() ; 

     return 1 ;

   }

--- nurbs/hnurbsS_sp.cpp.orig	Mon May 13 14:07:46 2002

+++ nurbs/hnurbsS_sp.cpp	Fri Dec  1 01:01:28 2006

@@ -43,7 +43,7 @@

 */

 template <class T, int N>

 void HNurbsSurfaceSP<T,N>::updateMaxU() {

-  if(degU>3){

+  if(this->degU>3){

 #ifdef USE_EXCEPTION

     throw NurbsError();

 #else

@@ -53,12 +53,12 @@

 #endif

   }

   else{

-    maxU.resize(P.rows()) ;

-    maxAtU_.resize(P.rows()) ;

-    for(int i=0;i<P.rows();++i){

-      if(!maxInfluence(i,U,degU,maxAtU_[i]))

+    maxU.resize(this->P.rows()) ;

+    maxAtU_.resize(this->P.rows()) ;

+    for(int i=0;i<this->P.rows();++i){

+      if(!maxInfluence(i,this->U,this->degU,maxAtU_[i]))

 	cerr << "Problem in maxInfluence U!\n" ;

-      maxU[i] = nurbsBasisFun(maxAtU_[i],i,degU,U) ;

+      maxU[i] = nurbsBasisFun(maxAtU_[i],i,this->degU,this->U) ;

     }

   }

@@ -78,7 +78,7 @@

 */

 template <class T, int N>

 void HNurbsSurfaceSP<T,N>::updateMaxV() {

-  if(degV>3){

+  if(this->degV>3){

 #ifdef USE_EXCEPTION

     throw NurbsError();

 #else

@@ -88,12 +88,12 @@

 #endif

   }

   else{

-    maxV.resize(P.cols()) ;

-    maxAtV_.resize(P.cols()) ;

-    for(int i=0;i<P.cols();++i){

-      if(!maxInfluence(i,V,degV,maxAtV_[i]))

+    maxV.resize(this->P.cols()) ;

+    maxAtV_.resize(this->P.cols()) ;

+    for(int i=0;i<this->P.cols();++i){

+      if(!maxInfluence(i,this->V,this->degV,maxAtV_[i]))

 	cerr << "Problem in maxInfluence V!\n" ;

-      maxV[i] = nurbsBasisFun(maxAtV_[i],i,degV,V) ;

+      maxV[i] = nurbsBasisFun(maxAtV_[i],i,this->degV,this->V) ;

     }

   }

@@ -113,18 +113,18 @@

 */

 template <class T, int N>

 void HNurbsSurfaceSP<T,N>::modSurfCPby(int i, int j, const HPoint_nD<T,N>& a) {

-  offset(i,j) +=  a / (maxU[i]*maxV[j]) ; 

-  if(baseLevel_){

+  this->offset(i,j) +=  a / (maxU[i]*maxV[j]) ; 

+  if(this->baseLevel_){

     Point_nD<T,N> vecOffset ; 

-    vecOffset = offset(i,j).x()*ivec(i,j) +

-      offset(i,j).y()*jvec(i,j) +

-      offset(i,j).z()*kvec(i,j) ;

-    P(i,j).x() = baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

-    P(i,j).y() = baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

-    P(i,j).z() = baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

+    vecOffset = this->offset(i,j).x()*this->ivec(i,j) +

+      this->offset(i,j).y()*this->jvec(i,j) +

+      this->offset(i,j).z()*this->kvec(i,j) ;

+    this->P(i,j).x() = this->baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

+    this->P(i,j).y() = this->baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

+    this->P(i,j).z() = this->baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

   }

   else

-    P(i,j) = offset(i,j) ; 

+    this->P(i,j) = this->offset(i,j) ; 

 }

 /*!

@@ -151,24 +151,24 @@

 void HNurbsSurfaceSP<T,N>::modOnlySurfCPby(int i, int j, const HPoint_nD<T,N>& a){

   int k ; 

-  P = offset ; 

+  this->P = this->offset ; 

   // by definition the offset has w = 0 , but this isn't valid for

   // the control points, increasing the w by 1, will generate a valid surface

-  if(baseLevel_)

-    for(k=0;k<P.rows();++k)

-      for(int l=0;l<P.cols();++l)

-	P(k,l).w() += T(1) ; 

+  if(this->baseLevel_)

+    for(k=0;k<this->P.rows();++k)

+      for(int l=0;l<this->P.cols();++l)

+	this->P(k,l).w() += T(1) ; 

   int sizeU, sizeV ;

-  sizeU = 2*degU+3 ; 

-  if(i-degU-1<0) sizeU += i-degU-1 ; 

-  if(i+degU+1>=P.rows()) sizeU -= i+degU+1-P.rows() ;

-

-  sizeV = 2*degV+3 ;

-  if(j-degV-1<0) sizeV += j-degV-1 ; 

-  if(j+degV+1>=P.cols()) sizeV -= j+degV+1-P.cols() ;

+  sizeU = 2*this->degU+3 ; 

+  if(i-this->degU-1<0) sizeU += i-this->degU-1 ; 

+  if(i+this->degU+1>=this->P.rows()) sizeU -= i+this->degU+1-this->P.rows() ;

+

+  sizeV = 2*this->degV+3 ;

+  if(j-this->degV-1<0) sizeV += j-this->degV-1 ; 

+  if(j+this->degV+1>=this->P.cols()) sizeV -= j+this->degV+1-this->P.cols() ;

   Vector<T> u(sizeU) ;

   Vector<T> v(sizeV) ;

@@ -179,16 +179,16 @@

   int n=0;

   int nu = 0 ;

   int nv = 0 ; 

-  for(k=i-degU-1;k<=i+degU+1;++k){

+  for(k=i-this->degU-1;k<=i+this->degU+1;++k){

     if(k<0)

       continue ;

-    if(k>=P.rows())

+    if(k>=this->P.rows())

       break ; 

     nv = 0 ;

-    for(int l=j-degV-1;l<=j+degV+1;++l){

+    for(int l=j-this->degV-1;l<=j+this->degV+1;++l){

       if(l<0)

 	continue ;

-      if(l>=P.cols())

+      if(l>=this->P.cols())

 	break ; 

       if( k == i && j==l){

 	pts[n].x() = a.x() ; 

@@ -216,12 +216,12 @@

   pv.resize(n) ; 

   if(NurbsSurface<T,N>::movePoint(u,v,pts,pu,pv)){

-    offset = P ; 

+    this->offset = this->P ; 

     // an offset shouldn't have a weight value.

-    if(baseLevel_)

-      for(k=0;k<P.rows();++k)

-	for(int l=0;l<P.cols();++l)

-	  offset(k,l).w() -= T(1) ; 

+    if(this->baseLevel_)

+      for(k=0;k<this->P.rows();++k)

+	for(int l=0;l<this->P.cols();++l)

+	  this->offset(k,l).w() -= T(1) ; 

   }

   updateSurface(); 

 }

@@ -262,7 +262,7 @@

 HNurbsSurfaceSP<T,N>* HNurbsSurfaceSP<T,N>::addLevel(int n, int s) {

   HNurbsSurfaceSP<T,N> *newLevel ;

-  if(nextLevel_)

+  if(this->nextLevel_)

     return 0 ;

   Vector<T> newU,newV ;

@@ -289,7 +289,7 @@

 HNurbsSurfaceSP<T,N>* HNurbsSurfaceSP<T,N>::addLevel() {

   HNurbsSurfaceSP<T,N> *newLevel ;

-  if(nextLevel_)

+  if(this->nextLevel_)

     return 0 ;

   newLevel = new HNurbsSurfaceSP<T,N>(this) ;

@@ -311,23 +311,23 @@

   levelP = nS.nextLevel() ;

   NurbsSurface<T,N>::operator=(nS) ;

-  rU = nS.rU ;

-  rV = nS.rV ;

-  offset = nS.offset ;

+  this->rU = nS.rU ;

+  this->rV = nS.rV ;

+  this->offset = nS.offset ;

   updateMaxUV() ; 

-  firstLevel_ = this ;

+  this->firstLevel_ = this ;

   if(levelP){

     HNurbsSurfaceSP<T,N> *newLevel ;

     newLevel =  new HNurbsSurfaceSP<T,N>(this) ; 

     newLevel->copy(*levelP) ;

-    nextLevel_ = newLevel ;

-    lastLevel_ = nextLevel_->lastLevel() ;

+    this->nextLevel_ = newLevel ;

+    this->lastLevel_ = this->nextLevel_->lastLevel() ;

   }

   else{

-    lastLevel_ = this ;

+    this->lastLevel_ = this ;

   }

 }

@@ -349,55 +349,55 @@

 template <class T, int N>

 void HNurbsSurfaceSP<T,N>::updateSurface(int i0, int j0){

   if(i0>=0 && j0>=0){

-    if(offset(i0,j0).x()==0.0 && offset(i0,j0).y()==0.0 && offset(i0,j0).z()==0.0)

+    if(this->offset(i0,j0).x()==0.0 && this->offset(i0,j0).y()==0.0 && this->offset(i0,j0).z()==0.0)

       return ;

   }

-  if(baseLevel_){

-    if(initBase()){

-      P = baseSurf.ctrlPnts() ;

-      U = baseSurf.knotU() ;

-      V = baseSurf.knotV() ;

-      degU = baseSurf.degreeU() ;

-      degV = baseSurf.degreeV() ;

+  if(this->baseLevel_){

+    if(this->initBase()){

+      this->P = this->baseSurf.ctrlPnts() ;

+      this->U = this->baseSurf.knotU() ;

+      this->V = this->baseSurf.knotV() ;

+      this->degU = this->baseSurf.degreeU() ;

+      this->degV = this->baseSurf.degreeV() ;

       updateMaxUV() ; 

     }

     if(i0>=0 && j0>=0){

       Point_nD<T,N> vecOffset ;

-      vecOffset = offset(i0,j0).x()*ivec(i0,j0) +

-	offset(i0,j0).y()*jvec(i0,j0) +

-	offset(i0,j0).z()*kvec(i0,j0) ;

-      P(i0,j0).x() = baseSurf.ctrlPnts()(i0,j0).x()+vecOffset.x() ;

-      P(i0,j0).y() = baseSurf.ctrlPnts()(i0,j0).y()+vecOffset.y() ;

-      P(i0,j0).z() = baseSurf.ctrlPnts()(i0,j0).z()+vecOffset.z() ;

+      vecOffset = this->offset(i0,j0).x()*this->ivec(i0,j0) +

+	this->offset(i0,j0).y()*this->jvec(i0,j0) +

+	this->offset(i0,j0).z()*this->kvec(i0,j0) ;

+      this->P(i0,j0).x() = this->baseSurf.ctrlPnts()(i0,j0).x()+vecOffset.x() ;

+      this->P(i0,j0).y() = this->baseSurf.ctrlPnts()(i0,j0).y()+vecOffset.y() ;

+      this->P(i0,j0).z() = this->baseSurf.ctrlPnts()(i0,j0).z()+vecOffset.z() ;

     }

     else{

-      for(int i=0;i<P.rows();++i)

-	for(int j=0;j<P.cols();++j){

-	  if(offset(i,j).x() != 0 || 

-	     offset(i,j).y() != 0 || offset(i,j).z() || 0){

+      for(int i=0;i<this->P.rows();++i)

+	for(int j=0;j<this->P.cols();++j){

+	  if(this->offset(i,j).x() != 0 || 

+	     this->offset(i,j).y() != 0 || this->offset(i,j).z() || 0){

 	    Point_nD<T,N> vecOffset ;

-	    vecOffset = offset(i,j).x()*ivec(i,j) +

-	      offset(i,j).y()*jvec(i,j) +

-	      offset(i,j).z()*kvec(i,j) ;

-	    P(i,j).x() = baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

-	    P(i,j).y() = baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

-	    P(i,j).z() = baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

+	    vecOffset = this->offset(i,j).x()*this->ivec(i,j) +

+	      this->offset(i,j).y()*this->jvec(i,j) +

+	      this->offset(i,j).z()*this->kvec(i,j) ;

+	    this->P(i,j).x() = this->baseSurf.ctrlPnts()(i,j).x()+vecOffset.x() ;

+	    this->P(i,j).y() = this->baseSurf.ctrlPnts()(i,j).y()+vecOffset.y() ;

+	    this->P(i,j).z() = this->baseSurf.ctrlPnts()(i,j).z()+vecOffset.z() ;

 	  }

 	}

     }

   }

   else{

     if(i0>=0 && j0>=0)

-      P(i0,j0) = offset(i0,j0) ;

+      this->P(i0,j0) = this->offset(i0,j0) ;

     else{

-      for(int i=0;i<P.rows();++i)

-	for(int j=0;j<P.cols();++j){

-	  P(i,j) = offset(i,j) ;

+      for(int i=0;i<this->P.rows();++i)

+	for(int j=0;j<this->P.cols();++j){

+	  this->P(i,j) = this->offset(i,j) ;

 	}

     }

   }

-  ++updateN ;

+  ++(this->updateN) ;

 }

 /*!

@@ -413,7 +413,7 @@

   if(!okMax())

     updateMaxUV() ; 

   if(upLevel>=0){

-    if(level()<=upLevel){

+    if(this->level()<=upLevel){

       this->updateSurface() ;

     }

   }

@@ -421,9 +421,9 @@

     this->updateSurface() ;

   }

-  if(upLevel>level() || upLevel<0){

-    if(nextLevel_)

-      ((HNurbsSurfaceSP<T,N>*)nextLevel_)->updateLevels(upLevel) ;

+  if(upLevel>this->level() || upLevel<0){

+    if(this->nextLevel_)

+      ((HNurbsSurfaceSP<T,N>*)this->nextLevel_)->updateLevels(upLevel) ;

   }

 }

@@ -458,10 +458,10 @@

     if(!fin.read((char*)&du,sizeof(int))) { delete []type ; return 0 ;}

     if(!fin.read((char*)&dv,sizeof(int))) { delete []type ; return 0 ;}

-    resize(nu,nv,du,dv) ;

+    this->resize(nu,nv,du,dv) ;

-    if(!fin.read((char*)U.memory(),sizeof(T)*U.n())) { delete []type ; return 0 ;}

-    if(!fin.read((char*)V.memory(),sizeof(T)*V.n())) { delete []type ; return 0 ;}

+    if(!fin.read((char*)this->U.memory(),sizeof(T)*this->U.n())) { delete []type ; return 0 ;}

+    if(!fin.read((char*)this->V.memory(),sizeof(T)*this->V.n())) { delete []type ; return 0 ;}

     if(!r1){

       p = new T[3*nu*nv] ;

@@ -469,10 +469,10 @@

       p2 = p ;

       for(int i=0;i<nu;i++)

 	for(int j=0;j<nv;j++){

-	  P(i,j).x() = *(p++) ;

-	  P(i,j).y() = *(p++) ;

-	  P(i,j).z() = *(p++) ;

-	  P(i,j).w() = 1.0 ;

+	  this->P(i,j).x() = *(p++) ;

+	  this->P(i,j).y() = *(p++) ;

+	  this->P(i,j).z() = *(p++) ;

+	  this->P(i,j).w() = 1.0 ;

 	}

       delete []p2 ;

     }

@@ -482,26 +482,26 @@

       p2 = p ;

       for(int i=0;i<nu;i++)

 	for(int j=0;j<nv;j++){

-	  P(i,j).x() = *(p++) ;

-	  P(i,j).y() = *(p++) ;

-	  P(i,j).z() = *(p++) ;

-	  P(i,j).w() = *(p++) ;

+	  this->P(i,j).x() = *(p++) ;

+	  this->P(i,j).y() = *(p++) ;

+	  this->P(i,j).z() = *(p++) ;

+	  this->P(i,j).w() = *(p++) ;

 	}

       delete []p2 ;

     }

-    offset = P ;

+    this->offset = this->P ;

     this->updateSurface() ;

   }

   else { // reading the offset information

     int ru,rv ;

     if(!fin.read((char*)&ru,sizeof(int))) { delete []type ; return 0 ;}

     if(!fin.read((char*)&rv,sizeof(int))) { delete []type ; return 0 ;}

-    rU.resize(ru) ;

-    rV.resize(rv) ;

-    if(rU.n()>0)

-      if(!fin.read((char*)rU.memory(),sizeof(T)*rU.n())) { delete []type ; return 0 ;}

-    if(rV.n()>0)

-      if(!fin.read((char*)rV.memory(),sizeof(T)*rV.n())) { delete []type ; return 0 ;}

+    this->rU.resize(ru) ;

+    this->rV.resize(rv) ;

+    if(this->rU.n()>0)

+      if(!fin.read((char*)this->rU.memory(),sizeof(T)*this->rU.n())) { delete []type ; return 0 ;}

+    if(this->rV.n()>0)

+      if(!fin.read((char*)this->rV.memory(),sizeof(T)*this->rV.n())) { delete []type ; return 0 ;}

     if(!fin.read((char*)&nu,sizeof(int))) { delete []type ; return 0 ;}

     if(!fin.read((char*)&nv,sizeof(int))) { delete []type ; return 0 ;}

@@ -509,16 +509,16 @@

     p = new T[4*nu*nv] ;

     if(!fin.read((char*)p,sizeof(T)*4*nu*nv)) { delete []type ; return 0 ;}

     p2 = p ;

-    offset.resize(nu,nv) ;

+    this->offset.resize(nu,nv) ;

     for(int i=0;i<nu;i++)

       for(int j=0;j<nv;j++){

-	offset(i,j).x() = *(p++) ;

-	offset(i,j).y() = *(p++) ;

-	offset(i,j).z() = *(p++) ;

-	offset(i,j).w() = *(p++) ;

+	this->offset(i,j).x() = *(p++) ;

+	this->offset(i,j).y() = *(p++) ;

+	this->offset(i,j).z() = *(p++) ;

+	this->offset(i,j).w() = *(p++) ;

       }

     delete []p2 ;    

-    --baseUpdateN ;

+    --(this->baseUpdateN) ;

     this->updateSurface() ;

   }

--- image/image.cpp.orig	Mon May 13 14:07:45 2002

+++ image/image.cpp	Thu Nov 30 23:57:14 2006

@@ -55,9 +55,9 @@

 void MatrixImage<T>::drawLine(int i1, int j1, int i2, int j2, T color){

   int i,j ;

   double mx,b ;

-  if(i1<0 || j1<0 || i1>rows() || j1>=cols()  ){

+  if(i1<0 || j1<0 || i1>this->rows() || j1>=this->cols()  ){

 #ifdef USE_EXCEPTION

-    throw OutOfBound2D(i1,j1,0,rows()-1,0,cols()-1) ;

+    throw OutOfBound2D(i1,j1,0,this->rows()-1,0,this->cols()-1) ;

 #else

     Error error("MatrixImage<T>::drawLine") ;

     error << "Error in drawing line\n Invalid index ("<< i1 << ", " << j1 << ") to ( " << i2 << ", " << j2 << ") \n" ;

@@ -65,9 +65,9 @@

 #endif

     return ;

   }

-  if(i2 <0 || j2<0 || i2>rows() || j2>=cols() ){

+  if(i2 <0 || j2<0 || i2>this->rows() || j2>=this->cols() ){

 #ifdef USE_EXCEPTION

-    throw OutOfBound2D(i2,j2,0,rows()-1,0,cols()-1) ;

+    throw OutOfBound2D(i2,j2,0,this->rows()-1,0,this->cols()-1) ;

 #else

     Error error("MatrixImage<T>::drawLine") ;

     error << "Error in drawing line\n Invalid index ("<< i1 << ", " << j1 << ") to ( " << i2 << ", " << j2 << ") \n" ;

@@ -79,7 +79,7 @@

   // check if line is vertical

   if(j1==j2){

     for(i=minimum(i1,i2);i<=maximum(i1,i2);i++)

-     operator()(i,j1) = color ;

+     this->operator()(i,j1) = color ;

     return ;

   }

   mx = (double)(i1-i2)/(double)(j1-j2) ;

@@ -88,13 +88,13 @@

     if(i1>i2){

       for(i=i1;i>=i2;i--){

 	j = int(((double)i-b)/mx) ;

-	operator()(i,j) = color ;

+	this->operator()(i,j) = color ;

       }

     }

     else{

       for(i=i1;i<=i2;i++){

 	j = (int)((i-b)/mx) ;

-	operator()(i,j) = color ;

+	this->operator()(i,j) = color ;

       }

     }

   }

@@ -102,13 +102,13 @@

     if(j1>j2){

       for(j=j1;j>=j2;j--){

 	i = (int)(mx*j+b) ;

-	operator()(i,j) = color ;

+	this->operator()(i,j) = color ;

       }

     }

     else{

       for(j=j1;j<=j2;j++){

 	i = (int)(mx*j+b) ;

-	operator()(i,j) = color ;

+	this->operator()(i,j) = color ;

       }

     }

   }

@@ -133,9 +133,9 @@

 void MatrixImage<T>::drawPoint(int i, int j, double r , T color){

   for(int y=i-int(ceil(r)) ; y<i+int(ceil(r)) ; y++)

     for(int x = j-int(ceil(r)) ; x<j+int(ceil(r)) ; x++){

-      if(y>=0 && y<rows() && x>=0 && x<cols()){

+      if(y>=0 && y<this->rows() && x>=0 && x<this->cols()){

 	if( ((y-i)*(y-i)+(x-j)*(x-j))<= r*r)

-	  operator()(y,x) = color ;

+	  this->operator()(y,x) = color ;

       }

     }

 }

@@ -153,14 +153,14 @@

 */

 template <class T>

 void MatrixImage<T>::store(Matrix<T>& a){

-  if(a.rows() != rows() || a.cols() != cols()) {

-    a.resize(rows(),cols()) ;

+  if(a.rows() != this->rows() || a.cols() != this->cols()) {

+    a.resize(this->rows(),this->cols()) ;

   }

   T *aptr, *bptr ;

   int size,i ;

   aptr = &a(0,0)-1 ;

-  bptr = m-1 ;

-  size = cols()*rows() ;

+  bptr = this->m-1 ;

+  size = this->cols()*this->rows() ;

   for(i=0;i<size;i++)

     *(++aptr) = *(++bptr) ;  

 }

--- matrix/list.h.orig	Mon May 13 14:07:45 2002

+++ matrix/list.h	Fri Dec  1 00:21:47 2006

@@ -89,6 +89,7 @@

   int resetMode() const { return reset_mode ; }

   void setResetMode(ListResetMode a ) { reset_mode = a ; }

+  BasicList<T> const &by_ref() { return *this ; }

 protected:

   BasicNode<T> *first_,*last_ ;

   int n ;

--- matrix/matrix.cpp.orig	Mon May 13 14:07:45 2002

+++ matrix/matrix.cpp	Thu Nov 30 23:43:36 2006

@@ -54,19 +54,19 @@

   if ( this == &a )

     return *this;

-  if ( a.rows() != rows() || a.cols() != cols() ){

+  if ( a.rows() != this->rows() || a.cols() != this->cols() ){

     resize(a.rows(),a.cols()) ;

   }

-  int sze = rows()*cols() ;

+  int sze = this->rows()*this->cols() ;

   T *ptr, *aptr ;

-  ptr = m-1 ;

+  ptr = this->m-1 ;

   aptr = a.m-1 ;

   for (i = sze; i > 0; --i)

     *(++ptr) = *(++aptr) ;

-  by_columns = a.by_columns;

+  this->by_columns = a.by_columns;

   return *this;

 }

@@ -100,10 +100,10 @@

 {

   int rwz,coz,i,j;

-  if ( rows() % a.rows() != 0 || cols() % a.cols() != 0 || rows() < a.rows() || cols() < a.cols() )

+  if ( this->rows() % a.rows() != 0 || this->cols() % a.cols() != 0 || this->rows() < a.rows() || this->cols() < a.cols() )

     {

 #ifdef USE_EXCEPTION

-      throw WrongSize2D(rows(),cols(),a.rows(),a.cols()) ;

+      throw WrongSize2D(this->rows(),this->cols(),a.rows(),a.cols()) ;

 #else

       Error error("Matrix<T>::submatrix");

       error << "Matrix and submatrix incommensurate" ;

@@ -111,10 +111,10 @@

 #endif

     }

-  if ( sr >= rows()/a.rows() || sr < 0 || sc >= cols()/a.cols() || sc < 0 )

+  if ( sr >= this->rows()/a.rows() || sr < 0 || sc >= this->cols()/a.cols() || sc < 0 )

     {

 #ifdef USE_EXCEPTION

-      throw OutOfBound2D(sr,sc,0,rows()/a.rows()-1,0,cols()/a.cols()-1) ;

+      throw OutOfBound2D(sr,sc,0,this->rows()/a.rows()-1,0,this->cols()/a.cols()-1) ;

 #else

       Error error("Matrix<T>::submatrix");

       error << "Submatrix location out of bounds.\nrowblock " << sr << ", " << rows()/a.rows() << " colblock " << sc << ", " << a.cols() << endl ;

@@ -133,7 +133,7 @@

   aptr = a.m - 1;

   for ( i = a.rows()-1; i >= 0; --i )

     {

-      ptr = &m[(i+rwz)*cols()+coz]-1 ;

+      ptr = &this->m[(i+rwz)*this->cols()+coz]-1 ;

       for ( j = a.cols(); j > 0; --j)

 	*(++ptr) = *(++aptr) ;

     }  

@@ -159,7 +159,7 @@

   // Assign matrix a to this matrix at (i,j)

   int i, j;

-  if ( (rw + a.rows()) > rows() || ( cl + a.cols()) > cols()) {

+  if ( (rw + a.rows()) > this->rows() || ( cl + a.cols()) > this->cols()) {

 #ifdef USE_EXCEPTION

     throw MatrixErr();

 #else

@@ -177,7 +177,7 @@

   T *pptr,*aptr ;

   aptr = a.m-1 ;

   for ( i = 0; i<a.rows(); ++i) {

-    pptr = &m[(i+rw)*cols()+cl]-1 ;

+    pptr = &this->m[(i+rw)*this->cols()+cl]-1 ;

     for ( j = 0; j < a.cols(); ++j)

       *(++pptr) = *(++aptr);

   }

@@ -208,7 +208,7 @@

 Matrix<T> Matrix<T>::get(int rw, int cl, int nr, int nc) const

 {

   Matrix<T> getmat(nr,nc) ;

-  if ( (rw+nr) > rows() || (cl+nc) > cols()) {

+  if ( (rw+nr) > this->rows() || (cl+nc) > this->cols()) {

 #ifdef USE_EXCEPTION

     throw MatrixErr();

 #else

@@ -228,7 +228,7 @@

   T *pptr,*aptr ;

   aptr = getmat.m-1;

   for (i = 0; i < nr; ++i) {

-    pptr = &m[(i+rw)*cols()+cl]-1 ;

+    pptr = &this->m[(i+rw)*this->cols()+cl]-1 ;

     for ( j = 0; j < nc; ++j)

       *(++aptr) = *(++pptr) ;

   }

@@ -252,11 +252,11 @@

   double sum, maxsum;

   int init=0 ;

   T *pptr ;

-  pptr = m-1 ;

+  pptr = this->m-1 ;

   maxsum = 0 ; // Silence the warning message

-  for(i=0;i<rows();++i){

+  for(i=0;i<this->rows();++i){

     sum = 0 ;

-    for ( j = 0; j < cols(); ++j) 

+    for ( j = 0; j < this->cols(); ++j) 

       sum += *(++pptr) ;

     if(init)

       maxsum = (maxsum>sum) ? maxsum : sum;

@@ -285,12 +285,12 @@

 {

   int i, iend;

-  iend = rows();

-  if ( iend > cols() )

-    iend = cols();

+  iend = this->rows();

+  if ( iend > this->cols() )

+    iend = this->cols();

   for (i = iend-1; i >=0; --i)

-    elem(i,i) = a;

+    this->elem(i,i) = a;

 }

@@ -308,10 +308,10 @@

 template <class T>

 Vector<T> Matrix<T>::getDiag(){

   int i, iend;

-  Vector<T> vec(minimum(rows(),cols())) ;

-  iend = minimum(rows(),cols());

+  Vector<T> vec(minimum(this->rows(),this->cols())) ;

+  iend = minimum(this->rows(),this->cols());

   for (i = iend-1; i >=0; --i)

-      vec[i] = elem(i,i);

+      vec[i] = this->elem(i,i);

   return vec ;

 }

@@ -328,8 +328,8 @@

 Matrix<T>& Matrix<T>::operator+=(double a)

 {

   T *p1 ;

-  p1 = m-1 ;

-  const int size = rows()*cols() ;

+  p1 = this->m-1 ;

+  const int size = this->rows()*this->cols() ;

   for(int i=size; i>0; --i)

     *(++p1) += a ;  

   return *this ;

@@ -348,8 +348,8 @@

 Matrix<T>& Matrix<T>::operator-=(double a)

 {

   T *p1 ;

-  p1 = m-1 ;

-  const int size = rows()*cols() ;

+  p1 = this->m-1 ;

+  const int size = this->rows()*this->cols() ;

   for(int i=size; i>0; --i)

     *(++p1) -= a ;  

   return *this ;

@@ -368,8 +368,8 @@

 Matrix<T>& Matrix<T>::operator*=(double a)

 {

   T *p1 ;

-  p1 = m-1 ;

-  const int size = rows()*cols() ;

+  p1 = this->m-1 ;

+  const int size = this->rows()*this->cols() ;

   for(int i=size; i>0; --i)

     *(++p1) *= a ;  

   return *this ;

@@ -388,8 +388,8 @@

 Matrix<T>& Matrix<T>::operator/=(double a)

 {

   T *p1 ;

-  p1 = m-1 ;

-  const int size = rows()*cols() ;

+  p1 = this->m-1 ;

+  const int size = this->rows()*this->cols() ;

   for(int i=size; i>0; --i)

     *(++p1) /= a ;  

   return *this ;

@@ -408,15 +408,15 @@

 template <class T> 

 Matrix<T>& Matrix<T>::operator+=(const Matrix<T> &a)

 {

-  if ( a.rows() != rows() || a.cols() != cols() )

+  if ( a.rows() != this->rows() || a.cols() != this->cols() )

     {

 #ifdef USE_EXCEPTION

-      throw WrongSize2D(rows(),cols(),a.rows(),a.cols());

+      throw WrongSize2D(this->rows(),this->cols(),a.rows(),a.cols());

 #else

       Error error("Matrix<T>::operator+=") ;

-      if ( rows() != a.rows() )

+      if ( this->rows() != a.rows() )

 	error << "Matrices are of diferent size, a.rows() = " << rows() << " and b.rows() = " << a.rows() << endl ;

-      if ( cols() != a.cols())

+      if ( this->cols() != a.cols())

 	error << "Matrices are of diferent size, a.cols() = " << cols() << " and b.cols() = " << a.cols() << endl ;

       error.fatal() ;

 #endif

@@ -425,8 +425,8 @@

   int i, sze ;

   T *aptr,*sptr ;

   aptr = a.m - 1 ;

-  sptr = m - 1 ;

-  sze = rows()*cols() ;

+  sptr = this->m - 1 ;

+  sze = this->rows()*this->cols() ;

   for (i = sze; i > 0; --i){

       *(++sptr) += *(++aptr) ;

   }

@@ -468,16 +468,16 @@

 template <class T> 

 Matrix<T>& Matrix<T>::operator-=(const Matrix<T> &a)

 {

-  if ( a.rows() != rows() || a.cols() != cols() )

+  if ( a.rows() != this->rows() || a.cols() != this->cols() )

     {

 #ifdef USE_EXCEPTION

-      throw WrongSize2D(rows(),cols(),a.rows(),a.cols());

+      throw WrongSize2D(this->rows(),this->cols(),a.rows(),a.cols());

 #else

       Error error("Matrix<T>::operator-=") ;

-      if ( rows() != a.rows() )

-	error << "Matrices are of diferent size, a.rows() = " << rows() << " and b.rows() = " << a.rows() << endl ;

-      if ( cols() != a.cols())

-	error << "Matrices are of diferent size, a.cols() = " << cols() << " and b.cols() = " << a.cols() << endl ;

+      if ( this->rows() != a.rows() )

+	error << "Matrices are of diferent size, a.rows() = " << this->rows() << " and b.rows() = " << a.rows() << endl ;

+      if ( this->cols() != a.cols())

+	error << "Matrices are of diferent size, a.cols() = " << this->cols() << " and b.cols() = " << a.cols() << endl ;

       error.fatal() ;

 #endif

     }

@@ -485,8 +485,8 @@

   int i, size;

   T *aptr,*sptr ;

   aptr = a.m - 1 ;

-  sptr = m - 1 ;

-  size = rows()*cols() ;

+  sptr = this->m - 1 ;

+  size = this->rows()*this->cols() ;

   for (i = size; i > 0; --i){

       *(++sptr) -= *(++aptr) ;

   }

@@ -742,14 +742,14 @@

 template <class T>

 T Matrix<T>::trace() const

 {

-  int size = rows();

+  int size = this->rows();

   T sum = (T)0;

-  if ( size > cols() )

-    size = cols();

+  if ( size > this->cols() )

+    size = this->cols();

   for (int d = 0; d < size; ++d)

-    sum += elem(d,d) ;

+    sum += this->elem(d,d) ;

   return sum;

 }

@@ -770,12 +770,12 @@

 template <class T>

 Matrix<T> Matrix<T>::herm() const

 {

-  int i, j, r = cols(), c = rows();

+  int i, j, r = this->cols(), c = this->rows();

   Matrix<T> adj(r,c);

   for (i = 0; i < r; ++i)

     for (j = 0; j < c; ++j)

-      adj.elem(i,j) = elem(j,i) ;

+      adj.elem(i,j) = this->elem(j,i) ;

   return adj;

@@ -794,11 +794,11 @@

 template <class T>

 Matrix<T> Matrix<T>::flop() const

 {					

-  Matrix<T> f(rows(),cols()) ;

-  for(int i=rows()-1;i>=0;--i)

-    for(int j=cols()-1;j>=0;--j)

+  Matrix<T> f(this->rows(),this->cols()) ;

+  for(int i=this->rows()-1;i>=0;--i)

+    for(int j=this->cols()-1;j>=0;--j)

       {

-	f(i,j) = elem(i,cols()-j-1);

+	f(i,j) = this->elem(i,this->cols()-j-1);

       }

   return f; 

 }

@@ -817,13 +817,13 @@

 {					

   // same as hermitian for real Matrix<T>

   int i, j;

-  const int& r = cols();

-  const int& c = rows();

+  const int& r = this->cols();

+  const int& c = this->rows();

   Matrix<T> adj(r,c);

   for (i = r-1; i >=0; --i)

     for (j = c-1; j >=0; --j)

-      adj.elem(i,j) = elem(j,i) ;

+      adj.elem(i,j) = this->elem(j,i) ;

   return adj; 

@@ -844,7 +844,7 @@

 int Matrix<T>::read(char* filename) {

   ifstream fin(filename) ;

   if(!fin) {

-    resize(1,1) ;

+    this->resize(1,1) ;

     return 0 ;

   }

   int r,c ;

@@ -855,8 +855,8 @@

   if(r) return 0 ;

   if(!fin.read((char*)&r,sizeof(int))) return 0 ;

   if(!fin.read((char*)&c,sizeof(int))) return 0 ;

-  resize(r,c) ;

-  if(!fin.read((char*)m,sizeof(T)*r*c)) return 0 ;

+  this->resize(r,c) ;

+  if(!fin.read((char*)this->m,sizeof(T)*r*c)) return 0 ;

   delete []type ;

   return 1 ;

@@ -877,11 +877,11 @@

 int Matrix<T>::read(char* filename,int r, int c) {

   ifstream fin(filename) ;

   if(!fin) {

-    resize(1,1) ;

+    this->resize(1,1) ;

     return 0 ;

   }

-  resize(r,c) ;

-  if(!fin.read((char*)m,sizeof(T)*r*c)) return 0 ;

+  this->resize(r,c) ;

+  if(!fin.read((char*)this->m,sizeof(T)*r*c)) return 0 ;

   return 1 ;

 }

@@ -904,11 +904,11 @@

   if(!fout)

     return 0 ;

   int r,c ;

-  r = rows() ; c = cols() ;

+  r = this->rows() ; c = this->cols() ;

   if(!fout.write((char*)&"matrix",sizeof(char)*6)) return 0 ;

   if(!fout.write((char*)&r,sizeof(int))) return 0 ;

   if(!fout.write((char*)&c,sizeof(int))) return 0 ;

-  if(!fout.write((char*)m,sizeof(T)*r*c)) return 0 ;

+  if(!fout.write((char*)this->m,sizeof(T)*r*c)) return 0 ;

   return 1;

 }

@@ -927,7 +927,7 @@

   ofstream fout(filename) ;

   if(!fout)

     return 0 ;

-  if(!fout.write((char*)m,sizeof(T)*rows()*cols())) return 0 ;

+  if(!fout.write((char*)this->m,sizeof(T)*this->rows()*this->cols())) return 0 ;

   return 1;

 }

--- numerical/matrixMat.cpp.orig	Mon May 13 14:07:45 2002

+++ numerical/matrixMat.cpp	Thu Nov 30 23:54:37 2006

@@ -48,9 +48,9 @@

 template <class T>

 LUMatrix<T>& LUMatrix<T>::operator=(const LUMatrix<T>& a){

   resize(a.rows(),a.cols()) ;

-  for(int i=0;i<rows();++i)

-    for(int j=0;j<cols();++j)

-      elem(i,j) = a(i,j) ;

+  for(int i=0;i<this->rows();++i)

+    for(int j=0;j<this->cols();++j)

+      this->elem(i,j) = a(i,j) ;

   pivot_ = a.pivot_ ;

   return *this ;

 }

@@ -90,7 +90,7 @@

   //	lu = a;	 must do it by copying or LUFACT will be recursively called !

   for(i=0;i<n;++i)

     for(j=0;j<n;++j)

-      elem(i,j) = a(i,j) ;

+      this->elem(i,j) = a(i,j) ;

   errval = 0;

   nm1 = n - 1;

@@ -129,24 +129,24 @@

 	    }

 	  pivot_[k] = l;

-	  if ( elem(l,k) != 0.0 )

+	  if ( this->elem(l,k) != 0.0 )

 	    {			// nonsingular pivot found 

 	      if (l != k ){	// interchange needed 

 		for (i = k; i < n; i++)

 		  {

-		    t = elem(l,i) ;

-		    elem(l,i) = elem(k,i) ;

-		    elem(k,i) = t ; 

+		    t = this->elem(l,i) ;

+		    this->elem(l,i) = this->elem(k,i) ;

+		    this->elem(k,i) = t ; 

 		  }

 		sign = -sign ;

 	      }

-	      q =  elem(k,k);	/* scale row */

+	      q =  this->elem(k,k);	/* scale row */

 	      for (i = kp1; i < n; i++)

 		{

-		  t = - elem(i,k)/q;

-		  elem(i,k) = t;

+		  t = - this->elem(i,k)/q;

+		  this->elem(i,k) = t;

 		  for (j = kp1; j < n; j++)

-		    elem(i,j) += t * elem(k,j);

+		    this->elem(i,j) += t * this->elem(k,j);

 		}

 	    }

 	  else		/* pivot singular */

@@ -156,7 +156,7 @@

     }

   pivot_[nm1] = nm1;

-  if (elem(nm1,nm1) == 0.0)

+  if (this->elem(nm1,nm1) == 0.0)

     errval = nm1;  

   return *this;

 }

@@ -196,9 +196,9 @@

 */

 template <class T>

 T LUMatrix<T>::determinant(){

-  T det = elem(0,0) ;

-  for(int i=1;i<rows();++i)

-    det *= elem(i,i) ;

+  T det = this->elem(0,0) ;

+  for(int i=1;i<this->rows();++i)

+    det *= this->elem(i,i) ;

   return det * (T)sign ;

 }

@@ -253,18 +253,18 @@

   T ten;

   int i, j, k, l, kb, kp1, nm1, n, coln;

-  if ( rows() != cols() )

+  if ( this->rows() != this->cols() )

     {

 #ifdef USE_EXCEPTION

-    throw WrongSize2D(rows(),cols(),0,0) ;

+    throw WrongSize2D(this->rows(),this->cols(),0,0) ;

 #else

       Error error("invm");

-      error << "matrix inverse, not square: " << rows() << " by " << cols() << endl;

+      error << "matrix inverse, not square: " << this->rows() << " by " << this->cols() << endl;

       error.fatal();

 #endif

     }

-  n = coln = rows();

+  n = coln = this->rows();

   inv = *this ;

@@ -338,13 +338,13 @@

 template <class T>

 Matrix<T> LUMatrix<T>::inverse() 

 {

-  if ( rows() != cols() )

+  if ( this->rows() != this->cols() )

     {

 #ifdef USE_EXCEPTION

-      throw WrongSize2D(rows(),cols(),0,0) ;

+      throw WrongSize2D(this->rows(),this->cols(),0,0) ;

 #else

       Error error("invm");

-      error << "matrix inverse, not square: " << rows() << " by " << cols() << endl;

+      error << "matrix inverse, not square: " << this->rows() << " by " << this->cols() << endl;

       error.fatal();

 #endif

     }

--- nurbs/matrixRT.cpp.orig	Mon May 13 14:07:46 2002

+++ nurbs/matrixRT.cpp	Fri Dec  1 00:43:46 2006

@@ -51,13 +51,13 @@

   // *this = C.translate(x,y,z)*B.rotate(ax,ay,az) ;

   rotate(ax,ay,az) ;

 #ifdef COLUMN_ORDER

-  m[12] = x ;

-  m[13] = y ;

-  m[14] = z ;  

+  this->m[12] = x ;

+  this->m[13] = y ;

+  this->m[14] = z ;  

 #else

-  m[3] = x ;

-  m[7] = y ;

-  m[11] = z ;

+  this->m[3] = x ;

+  this->m[7] = y ;

+  this->m[11] = z ;

 #endif

 }

@@ -71,8 +71,8 @@

  */

 template <class T>

 MatrixRT<T>::MatrixRT() : Matrix<T>(4,4) {

-  reset(0) ;

-  diag(1.0) ;

+  this->reset(0) ;

+  this->diag(1.0) ;

 }

 /*!

@@ -144,33 +144,33 @@

   t10 = cos(ax);

   t13 = t4*t6;

 #ifdef COLUMN_ORDER

-  m[0] = t1*t2;

-  m[4] = -t4*t2;

-  m[8] = t6;

-  m[12] = 0 ;

-  m[1] = t7*t8+t4*t10;

-  m[5] = -t13*t8+t1*t10;

-  m[9] = -t2*t8;

-  m[13] = 0 ;

-  m[2] = -t7*t10+t4*t8;

-  m[6] = t13*t10+t1*t8;

-  m[10] = t2*t10;

-  m[14] = m[3] = m[7] = m[11] = 0.0 ;

-  m[15] = 1.0 ;

+  this->m[0] = t1*t2;

+  this->m[4] = -t4*t2;

+  this->m[8] = t6;

+  this->m[12] = 0 ;

+  this->m[1] = t7*t8+t4*t10;

+  this->m[5] = -t13*t8+t1*t10;

+  this->m[9] = -t2*t8;

+  this->m[13] = 0 ;

+  this->m[2] = -t7*t10+t4*t8;

+  this->m[6] = t13*t10+t1*t8;

+  this->m[10] = t2*t10;

+  this->m[14] = m[3] = m[7] = m[11] = 0.0 ;

+  this->m[15] = 1.0 ;

 #else

-  m[0] = t1*t2;

-  m[1] = -t4*t2;

-  m[2] = t6;

-  m[3] = 0 ;

-  m[4] = t7*t8+t4*t10;

-  m[5] = -t13*t8+t1*t10;

-  m[6] = -t2*t8;

-  m[7] = 0 ;

-  m[8] = -t7*t10+t4*t8;

-  m[9] = t13*t10+t1*t8;

-  m[10] = t2*t10;

-  m[11] = m[12] = m[13] = m[14] = 0 ;

-  m[15] = 1.0 ;

+  this->m[0] = t1*t2;

+  this->m[1] = -t4*t2;

+  this->m[2] = t6;

+  this->m[3] = 0 ;

+  this->m[4] = t7*t8+t4*t10;

+  this->m[5] = -t13*t8+t1*t10;

+  this->m[6] = -t2*t8;

+  this->m[7] = 0 ;

+  this->m[8] = -t7*t10+t4*t8;

+  this->m[9] = t13*t10+t1*t8;

+  this->m[10] = t2*t10;

+  this->m[11] = this->m[12] = this->m[13] = this->m[14] = 0 ;

+  this->m[15] = 1.0 ;

 #endif

   return *this ;

 }

@@ -203,33 +203,33 @@

   t9 = (T)sin((double)ax);

   t17 = t4*t7;

 #ifdef COLUMN_ORDER

-  m[0] = t1*t2;

-  m[4] = -t4*t5+t8*t9;

-  m[8] = t4*t9+t8*t5;

-  m[12] = 0.0 ;

-  m[1] = t4*t2;

-  m[5] = t1*t5+t17*t9;

-  m[9] = -t1*t9+t17*t5;

-  m[13] = 0.0 ;

-  m[2] = -t7;

-  m[6] = t2*t9;

-  m[10] = t2*t5;

-  m[14] = m[3] = m[7] = m[11] = 0 ;

-  m[15] = 1.0 ;

+  this->m[0] = t1*t2;

+  this->m[4] = -t4*t5+t8*t9;

+  this->m[8] = t4*t9+t8*t5;

+  this->m[12] = 0.0 ;

+  this->m[1] = t4*t2;

+  this->m[5] = t1*t5+t17*t9;

+  this->m[9] = -t1*t9+t17*t5;

+  this->m[13] = 0.0 ;

+  this->m[2] = -t7;

+  this->m[6] = t2*t9;

+  this->m[10] = t2*t5;

+  this->m[14] = m[3] = m[7] = m[11] = 0 ;

+  this->m[15] = 1.0 ;

 #else

-  m[0] = t1*t2;

-  m[1] = -t4*t5+t8*t9;

-  m[2] = t4*t9+t8*t5;

-  m[3] = 0.0 ;

-  m[4] = t4*t2;

-  m[5] = t1*t5+t17*t9;

-  m[6] = -t1*t9+t17*t5;

-  m[7] = 0.0 ;

-  m[8] = -t7;

-  m[9] = t2*t9;

-  m[10] = t2*t5;

-  m[11] = m[12] = m[13] = m[14] = 0 ;

-  m[15] = 1.0 ;

+  this->m[0] = t1*t2;

+  this->m[1] = -t4*t5+t8*t9;

+  this->m[2] = t4*t9+t8*t5;

+  this->m[3] = 0.0 ;

+  this->m[4] = t4*t2;

+  this->m[5] = t1*t5+t17*t9;

+  this->m[6] = -t1*t9+t17*t5;

+  this->m[7] = 0.0 ;

+  this->m[8] = -t7;

+  this->m[9] = t2*t9;

+  this->m[10] = t2*t5;

+  this->m[11] = this->m[12] = this->m[13] = this->m[14] = 0 ;

+  this->m[15] = 1.0 ;

 #endif

   return *this ;

 }

@@ -245,16 +245,16 @@

  */

 template <class T>

 MatrixRT<T>& MatrixRT<T>::translate(T x, T y, T z){

-  reset(0) ;

-  diag(1.0) ;

+  this->reset(0) ;

+  this->diag(1.0) ;

 #ifdef COLUMN_ORDER

-  m[12] = x ;

-  m[13] = y ;

-  m[14] = z ;

+  this->m[12] = x ;

+  this->m[13] = y ;

+  this->m[14] = z ;

 #else

-  m[3] = x ;

-  m[7] = y ;

-  m[11] = z ;

+  this->m[3] = x ;

+  this->m[7] = y ;

+  this->m[11] = z ;

 #endif

   return *this ;

 }

@@ -271,11 +271,11 @@

  */

 template <class T>

 MatrixRT<T>& MatrixRT<T>::scale(T x, T y, T z){

-  reset(0) ;

-  m[0] = x ;

-  m[5] = y ;

-  m[10] = z ;

-  m[15] = 1.0 ;

+  this->reset(0) ;

+  this->m[0] = x ;

+  this->m[5] = y ;

+  this->m[10] = z ;

+  this->m[15] = 1.0 ;

   return *this ;

 }

@@ -416,7 +416,7 @@

     error.fatal() ;

   }

   T *a,*b ;

-  a = m-1 ;

+  a = this->m-1 ;

   b = M[0] - 1 ;

   for(int i=0;i<16;++i){

     *(++a) = *(++b) ;

@@ -435,7 +435,7 @@

 template <class T>

 MatrixRT<T>& MatrixRT<T>::operator=(const MatrixRT<T>& M) {

   T *a,*b ;

-  a = m-1 ;

+  a = this->m-1 ;

   b = M.m - 1 ;

   for(int i=0;i<16;++i){

     *(++a) = *(++b) ;

--- nurbs/nurbs.cpp.orig	Fri May 24 10:25:49 2002

+++ nurbs/nurbs.cpp	Fri Dec  1 00:22:20 2006

@@ -28,7 +28,7 @@

 #include <nurbsS.h>

 #include "integrate.h"

-#include <malloc.h>

+#include <stdlib.h>

 /*!

  */

@@ -391,9 +391,9 @@

   T du,dv ;

   // compute a coarse distance for the curve

   Point_nD<T,N> a,b,c ;

-  a = pointAt(0.0) ;

-  b = pointAt(0.5) ;

-  c = pointAt(1.0) ;

+  a = this->pointAt(0.0) ;

+  b = this->pointAt(0.5) ;

+  c = this->pointAt(1.0) ;

   T distance = norm(b-a) + norm(c-b) ;

@@ -5202,7 +5202,7 @@

 */

 template <class T, int N>

 BasicList<Point_nD<T,N> > NurbsCurve<T,N>::tesselate(T tolerance,BasicList<T> *uk) const {

-  BasicList<Point_nD<T,N> > list,list2 ;

+  BasicList<Point_nD<T,N> > list, list2 ;

   NurbsCurveArray<T,N> ca ;

   decompose(ca) ;

@@ -5249,7 +5249,7 @@

   }

   else{

     for(int i=0;i<ca.n();++i){

-      list2 = ca[i].tesselate(tolerance,uk) ;

+      list2 = ca[i].tesselate(tolerance,uk).by_ref() ;

       // remove the last point from the list to elliminate

       list.erase((BasicNode<Point_nD<T,N> >*)list.last()) ;

--- nurbs/nurbsS.cpp.orig	Mon May 13 14:07:46 2002

+++ nurbs/nurbsS.cpp	Fri Dec  1 00:32:26 2006

@@ -30,7 +30,7 @@

 #include "integrate.h"

 #ifdef USING_VCC

-#include <malloc.h>

+#include <stdlib.h>

 #endif

 /*!

@@ -3762,12 +3762,12 @@

   // we use and angle of 36 to view the object

   // and position the rest according to this.

   Point_nD<T,N> minP, maxP ;

-  minP.x() = extremum(1,coordX) ;

-  minP.y() = extremum(1,coordY) ;

-  minP.z() = extremum(1,coordZ) ;

-  maxP.x() = extremum(0,coordX) ;

-  maxP.y() = extremum(0,coordY) ;

-  maxP.z() = extremum(0,coordZ) ;

+  minP.x() = this->extremum(1,coordX) ;

+  minP.y() = this->extremum(1,coordY) ;

+  minP.z() = this->extremum(1,coordZ) ;

+  maxP.x() = this->extremum(0,coordX) ;

+  maxP.y() = this->extremum(0,coordY) ;

+  maxP.z() = this->extremum(0,coordZ) ;

   Point_nD<T,N> lookAt  ;

   lookAt.x() = (minP.x()+maxP.x())/2.0 ;

@@ -3860,12 +3860,12 @@

   // we use and angle of 36 to view the object

   // and position the rest according to this.

   Point_nD<T,N> minP, maxP ;

-  minP.x() = extremum(1,coordX) ;

-  minP.y() = extremum(1,coordY) ;

-  minP.z() = extremum(1,coordZ) ;

-  maxP.x() = extremum(0,coordX) ;

-  maxP.y() = extremum(0,coordY) ;

-  maxP.z() = extremum(0,coordZ) ;

+  minP.x() = this->extremum(1,coordX) ;

+  minP.y() = this->extremum(1,coordY) ;

+  minP.z() = this->extremum(1,coordZ) ;

+  maxP.x() = this->extremum(0,coordX) ;

+  maxP.y() = this->extremum(0,coordY) ;

+  maxP.z() = this->extremum(0,coordZ) ;

   Point_nD<T,N> lookAt  ;

   lookAt.x() = (minP.x()+maxP.x())/2.0 ;

@@ -4045,12 +4045,12 @@

   }

   Point_nD<T,N> minP, maxP ;

-  minP.x() = extremum(1,coordX) ;

-  minP.y() = extremum(1,coordY) ;

-  minP.z() = extremum(1,coordZ) ;

-  maxP.x() = extremum(0,coordX) ;

-  maxP.y() = extremum(0,coordY) ;

-  maxP.z() = extremum(0,coordZ) ;

+  minP.x() = this->extremum(1,coordX) ;

+  minP.y() = this->extremum(1,coordY) ;

+  minP.z() = this->extremum(1,coordZ) ;

+  maxP.x() = this->extremum(0,coordX) ;

+  maxP.y() = this->extremum(0,coordY) ;

+  maxP.z() = this->extremum(0,coordZ) ;

   Point_nD<T,N> lookAt  ;

   lookAt.x() = (minP.x()+maxP.x())/2.0 ;

--- nurbs/nurbsS_sp.cpp.orig	Mon May 13 14:07:46 2002

+++ nurbs/nurbsS_sp.cpp	Fri Dec  1 00:52:04 2006

@@ -43,7 +43,7 @@

 */

 template <class T, int N>

 void NurbsSurfaceSP<T,N>::updateMaxU() {

-  if(degU>3){

+  if(this->degU>3){

 #ifdef USE_EXCEPTION

     throw NurbsInputError();

 #else

@@ -53,12 +53,12 @@

 #endif

   }

   else{

-    maxU.resize(P.rows()) ;

-    maxAtU_.resize(P.rows()) ;

-    for(int i=0;i<P.rows();++i){

-      if(!maxInfluence(i,U,degU,maxAtU_[i]))

+    maxU.resize(this->P.rows()) ;

+    maxAtU_.resize(this->P.rows()) ;

+    for(int i=0;i<this->P.rows();++i){

+      if(!maxInfluence(i,this->U,this->degU,maxAtU_[i]))

 	cerr << "Problem in maxInfluence U!\n" ;

-      maxU[i] = nurbsBasisFun(maxAtU_[i],i,degU,U) ;

+      maxU[i] = nurbsBasisFun(maxAtU_[i],i,this->degU,this->U) ;

     }

   }

@@ -78,7 +78,7 @@

 */

 template <class T, int N>

 void NurbsSurfaceSP<T,N>::updateMaxV() {

-  if(degV>3){

+  if(this->degV>3){

 #ifdef USE_EXCEPTION

     throw NurbsInputError();

 #else

@@ -88,12 +88,12 @@

 #endif

   }

   else{

-    maxV.resize(P.cols()) ;

-    maxAtV_.resize(P.cols()) ;

-    for(int i=0;i<P.cols();++i){

-      if(!maxInfluence(i,V,degV,maxAtV_[i]))

+    maxV.resize(this->P.cols()) ;

+    maxAtV_.resize(this->P.cols()) ;

+    for(int i=0;i<this->P.cols();++i){

+      if(!maxInfluence(i,this->V,this->degV,maxAtV_[i]))

 	cerr << "Problem in maxInfluence V!\n" ;

-      maxV[i] = nurbsBasisFun(maxAtV_[i],i,degV,V) ;

+      maxV[i] = nurbsBasisFun(maxAtV_[i],i,this->degV,this->V) ;

     }

   }

@@ -124,11 +124,11 @@

 NurbsSurfaceSP<T,N> NurbsSurfaceSP<T,N>::generateParallel(T d) const {

   NurbsSurfaceSP<T,N> p(*this) ;

-  Vector< Point_nD<T,N> > offset(P.rows()*P.cols()) ;

-  Vector<T> ur(P.rows()*P.cols()) ;

-  Vector<T> vr(P.rows()*P.cols()) ;

-  Vector_INT Du(P.rows()*P.cols()) ;

-  Vector_INT Dv(P.rows()*P.cols()) ;

+  Vector< Point_nD<T,N> > offset(this->P.rows()*this->P.cols()) ;

+  Vector<T> ur(this->P.rows()*this->P.cols()) ;

+  Vector<T> vr(this->P.rows()*this->P.cols()) ;

+  Vector_INT Du(this->P.rows()*this->P.cols()) ;

+  Vector_INT Dv(this->P.rows()*this->P.cols()) ;

   Du.reset(0) ;

   Dv.reset(0) ;

@@ -137,8 +137,8 @@

   no = 0 ;

-  for(i=0;i<P.rows();++i)

-    for(j=0;j<P.cols();++j){

+  for(i=0;i<this->P.rows();++i)

+    for(j=0;j<this->P.cols();++j){

       Point_nD<T,N> norm ;

       norm = normal(maxAtU_[i],maxAtV_[j]) ;

       if(norm.x() == T(0) && 

@@ -155,19 +155,19 @@

 	  norm /= T(2) ;

 	  ok = 1 ;

 	}

-	if(i==P.rows()-1 && j==P.cols()-1){

+	if(i==this->P.rows()-1 && j==this->P.cols()-1){

 	  norm = normal(maxAtU_[i]-delta,maxAtV_[j]) ;

 	  norm += normal(maxAtU_[i],maxAtV_[j]-delta) ;

 	  norm /= T(2) ;

 	  ok = 1 ;

 	}

-	if(i==0 && j==P.cols()-1){

+	if(i==0 && j==this->P.cols()-1){

 	  norm = normal(maxAtU_[i]-delta,maxAtV_[j]) ;

 	  norm += normal(maxAtU_[i],maxAtV_[j]+delta) ;

 	  norm /= T(2) ;

 	  ok = 1 ;

 	}

-	if(i==P.rows()-1 && j==0){

+	if(i==this->P.rows()-1 && j==0){

 	  norm = normal(maxAtU_[i]-delta,maxAtV_[j]) ;

 	  norm += normal(maxAtU_[i],maxAtV_[j]+delta) ;

 	  norm /= T(2) ;

@@ -178,7 +178,7 @@

 	  while(norm.x() == T(0) && 

 	     norm.y() == T(0) &&

 	     norm.z() == T(0)){

-	    if( nt*d >(U[U.n()-1]-U[0])){

+	    if( nt*d >(this->U[this->U.n()-1]-this->U[0])){

 #ifdef USE_EXCEPTION

 	      throw NurbsComputationError();

 #else

@@ -188,12 +188,12 @@

 #endif

 	    }

 	    T u1,u2,v1,v2 ;

-	    if(i==0 || i==P.rows()-1){

+	    if(i==0 || i==this->P.rows()-1){

 	      u1 = u2 = maxAtU_[i] ;

 	      v1 = maxAtV_[j]+ nt*delta ;

 	      v2 = maxAtV_[j]- nt*delta ;

-	      if(v1>V[V.n()-1]) v1 = V[V.n()-1] ;

-	      if(v2<V[0]) v2 = V[0] ;

+	      if(v1>this->V[this->V.n()-1]) v1 = this->V[this->V.n()-1] ;

+	      if(v2<this->V[0]) v2 = this->V[0] ;

 	      norm = normal(u1,v1);

 	      norm += normal(u2,v2) ;

 	      norm /= 2 ; 

@@ -202,8 +202,8 @@

 	      u1 = maxAtU_[i]- nt*delta ;

 	      u2 = maxAtU_[i]+ nt*delta ;

 	      v1 = v2 = maxAtV_[j] ;

-	      if(u1 < U[0]) u1 = U[0] ;