From pete@tortall.net Fri Dec 1 09:26:59 2006 Return-Path: Received: from mx1.FreeBSD.org (mx1.freebsd.org [69.147.83.52]) by hub.freebsd.org (Postfix) with ESMTP id 98F3316A412 for ; Fri, 1 Dec 2006 09:26:59 +0000 (UTC) (envelope-from pete@tortall.net) Received: from cvs.tortall.net (cvs.tortall.net [69.55.238.110]) by mx1.FreeBSD.org (Postfix) with ESMTP id 3C50243CA2 for ; Fri, 1 Dec 2006 09:26:46 +0000 (GMT) (envelope-from pete@tortall.net) Received: from localhost (cvs [69.55.238.110]) by cvs.tortall.net (Postfix) with ESMTP id 0F60E18CBA for ; Fri, 1 Dec 2006 01:26:59 -0800 (PST) Received: from cvs.tortall.net ([69.55.238.110]) by localhost (cvs.tortall.net [69.55.238.110]) (amavisd-new, port 10024) with ESMTP id tE36ohDPimNq for ; Fri, 1 Dec 2006 01:26:53 -0800 (PST) Received: by cvs.tortall.net (Postfix, from userid 1000) id A3FF818E0F; Fri, 1 Dec 2006 01:26:53 -0800 (PST) Message-Id: <20061201092653.A3FF818E0F@cvs.tortall.net> Date: Fri, 1 Dec 2006 01:26:53 -0800 (PST) From: Peter Johnson Reply-To: Peter Johnson To: FreeBSD-gnats-submit@freebsd.org Cc: Subject: [PATCH] graphics/nurbs++: Fix BROKENness X-Send-Pr-Version: 3.113 X-GNATS-Notify: >Number: 106117 >Category: ports >Synopsis: [PATCH] graphics/nurbs++: Fix BROKENness >Confidential: no >Severity: non-critical >Priority: low >Responsible: freebsd-ports-bugs >State: closed >Quarter: >Keywords: >Date-Required: >Class: update >Submitter-Id: current-users >Arrival-Date: Fri Dec 01 09:30:15 GMT 2006 >Closed-Date: Fri Dec 01 09:55:45 GMT 2006 >Last-Modified: Fri Dec 1 10:00:26 GMT 2006 >Originator: Peter Johnson >Release: FreeBSD 6.1-RELEASE i386 >Organization: >Environment: System: FreeBSD 6.1-RELEASE >Description: Fix C++ compiler errors. These errors have the port currently marked as BROKEN. >How-To-Repeat: Port is marked BROKEN on >=5.x (gcc 3.4.2 or later). >Fix: Patch attached. I have one patch file per file because that was easiest for me to work with when fixing the errors, but feel free to consolidate if that's preferable. --- nurbs-unbreak.patch begins here --- Index: Makefile =================================================================== RCS file: /home/ncvs/ports/graphics/nurbs++/Makefile,v retrieving revision 1.16 diff -u -r1.16 Makefile --- Makefile 14 Aug 2006 23:06:37 -0000 1.16 +++ Makefile 1 Dec 2006 09:19:00 -0000 @@ -7,7 +7,7 @@ PORTNAME= nurbs++ PORTVERSION= 3.0.11 -PORTREVISION= 1 +PORTREVISION= 2 CATEGORIES= graphics MASTER_SITES= ${MASTER_SITE_SOURCEFORGE} MASTER_SITE_SUBDIR= libnurbs @@ -21,14 +21,4 @@ MAN1= nurbs++-config.1 -.include - -.if ${OSVERSION} >= 502126 -BROKEN= "Does not compile with gcc 3.4.2" -.endif - -pre-patch: - @${REINPLACE_CMD} -e 's,,,' \ - ${WRKSRC}/nurbs/nurbs.cpp ${WRKSRC}/nurbs/nurbsS.cpp - -.include +.include Index: files/patch-cvector.h =================================================================== RCS file: files/patch-cvector.h diff -N files/patch-cvector.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-cvector.h 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,16 @@ +--- 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& v) : Vector(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 ; Index: files/patch-d_nurbsSub.cpp =================================================================== RCS file: files/patch-d_nurbsSub.cpp diff -N files/patch-d_nurbsSub.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-d_nurbsSub.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,13 @@ +--- 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 NurbSurface::epsilon = 1e-6 ; +- double SurfSample::epsilon = 1e-6 ; ++ template <> double NurbSurface::epsilon = 1e-6 ; ++ template <> double SurfSample::epsilon = 1e-6 ; + + template void DrawSubdivision( NurbSurface *, double tolerance ); + template void DrawEvaluation( NurbSurface * ); Index: files/patch-f_nurbsSub.cpp =================================================================== RCS file: files/patch-f_nurbsSub.cpp diff -N files/patch-f_nurbsSub.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-f_nurbsSub.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,13 @@ +--- 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 NurbSurface::epsilon = 1e-6 ; +- float SurfSample::epsilon = 1e-6 ; ++ template <> float NurbSurface::epsilon = 1e-6 ; ++ template <> float SurfSample::epsilon = 1e-6 ; + + template void DrawSubdivision( NurbSurface *, float tolerance ); + template void DrawEvaluation( NurbSurface * ); Index: files/patch-hnurbsS.cpp =================================================================== RCS file: files/patch-hnurbsS.cpp diff -N files/patch-hnurbsS.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-hnurbsS.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,381 @@ +--- 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 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;iP.rows();++i) ++ for(int j=0;jP.cols();++j){ + if(offset(i,j).x() != 0 || + offset(i,j).y() != 0 || offset(i,j).z() || 0){ + Point_nD 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;iP.rows();++i) ++ for(int j=0;jP.cols();++j){ ++ this->P(i,j) = offset(i,j) ; + } + } + } +@@ -554,17 +554,17 @@ + return mod ; + } + +- if(uknotU()[knotU().n()-1]) ++ if(uknotU()[0] || u>this->knotU()[this->knotU().n()-1]) + return -1 ; +- if(vknotU()[knotV().n()-1]) ++ if(vknotV()[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(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(0,0,0,0)) + return level_ ; + } + +@@ -742,16 +742,16 @@ + template + void HNurbsSurface::splitUV(int nu, int nv, Vector &nU, Vector &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;iknotU()[i-1]){ +- T a = knotU()[i-1] ; +- T b = knotU()[i] ; ++ for(i=1;iknotU().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 knotV()[i-1]){ +- T a = knotV()[i-1] ; +- T b = knotV()[i] ; ++ for(i=1;iknotV().n();++i){ ++ if(this->knotV()[i] > this->knotV()[i-1]){ ++ T a = this->knotV()[i-1] ; ++ T b = this->knotV()[i] ; + + for(j=0;jdegU ; + 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;iknotU()[i-1]){ +- T a = knotU()[i-1] ; +- T b = knotU()[i] ; ++ for(i=1;iknotU().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 knotV()[i-1]){ +- T a = knotV()[i-1] ; +- T b = knotV()[i] ; ++ for(i=1;iknotV().n();++i){ ++ if(this->knotV()[i] > this->knotV()[i-1]){ ++ T a = this->knotV()[i-1] ; ++ T b = this->knotV()[i] ; + + for(j=0;jresize(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;iP(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;iP(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*)°U,sizeof(int))) return 0 ; +- if(!fout.write((char*)°V,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;iP.rows();i++) ++ for(int j=0;jP.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=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 osurf(degU,degV,U,V,offset) ; ++ NurbsSurface 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=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 osurf(degU,degV,U,V,offset) ; ++ NurbsSurface osurf(this->degU,this->degV,this->U,this->V,offset) ; + + osurf.refineKnotV(Xv) ; + +@@ -1370,26 +1370,26 @@ + */ + template + int HNurbsSurface::movePointOffset(T u, T v, const Point_nD& 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;iP.rows();++i) ++ for(int j=0;jP.cols();++j){ ++ this->P(i,j).w() += T(1) ; + } + + if(NurbsSurface::movePoint(u,v,delta)){ +- offset = P ; ++ offset = this->P ; + // need to reset the offset weights + if(baseLevel_) +- for(int i=0;iP.rows();++i) ++ for(int j=0;jP.cols();++j){ ++ this->P(i,j).w() -= T(1) ; + } + +- P = baseSurf.ctrlPnts() ; ++ this->P = baseSurf.ctrlPnts() ; + updateSurface() ; + return 1 ; + } Index: files/patch-hnurbsS_sp.cpp =================================================================== RCS file: files/patch-hnurbsS_sp.cpp diff -N files/patch-hnurbsS_sp.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-hnurbsS_sp.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,406 @@ +--- 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 + void HNurbsSurfaceSP::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;iP.rows()) ; ++ maxAtU_.resize(this->P.rows()) ; ++ for(int i=0;iP.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 + void HNurbsSurfaceSP::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;iP.cols()) ; ++ maxAtV_.resize(this->P.cols()) ; ++ for(int i=0;iP.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 + void HNurbsSurfaceSP::modSurfCPby(int i, int j, const HPoint_nD& 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 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::modOnlySurfCPby(int i, int j, const HPoint_nD& 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;kbaseLevel_) ++ for(k=0;kP.rows();++k) ++ for(int l=0;lP.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 u(sizeU) ; + Vector 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::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;kbaseLevel_) ++ for(k=0;kP.rows();++k) ++ for(int l=0;lP.cols();++l) ++ this->offset(k,l).w() -= T(1) ; + } + updateSurface(); + } +@@ -262,7 +262,7 @@ + HNurbsSurfaceSP* HNurbsSurfaceSP::addLevel(int n, int s) { + HNurbsSurfaceSP *newLevel ; + +- if(nextLevel_) ++ if(this->nextLevel_) + return 0 ; + + Vector newU,newV ; +@@ -289,7 +289,7 @@ + HNurbsSurfaceSP* HNurbsSurfaceSP::addLevel() { + HNurbsSurfaceSP *newLevel ; + +- if(nextLevel_) ++ if(this->nextLevel_) + return 0 ; + + newLevel = new HNurbsSurfaceSP(this) ; +@@ -311,23 +311,23 @@ + levelP = nS.nextLevel() ; + + NurbsSurface::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 *newLevel ; + newLevel = new HNurbsSurfaceSP(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 + void HNurbsSurfaceSP::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 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;iP.rows();++i) ++ for(int j=0;jP.cols();++j){ ++ if(this->offset(i,j).x() != 0 || ++ this->offset(i,j).y() != 0 || this->offset(i,j).z() || 0){ + Point_nD 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;iP.rows();++i) ++ for(int j=0;jP.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*)nextLevel_)->updateLevels(upLevel) ; ++ if(upLevel>this->level() || upLevel<0){ ++ if(this->nextLevel_) ++ ((HNurbsSurfaceSP*)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;iP(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;iP(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;ioffset(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() ; + } + Index: files/patch-image.cpp =================================================================== RCS file: files/patch-image.cpp diff -N files/patch-image.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-image.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,98 @@ +--- 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::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::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::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::drawPoint(int i, int j, double r , T color){ + for(int y=i-int(ceil(r)) ; y=0 && y=0 && x=0 && yrows() && x>=0 && xcols()){ + 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 + void MatrixImage::store(Matrix& 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 const &by_ref() { return *this ; } + protected: + BasicNode *first_,*last_ ; + int n ; Index: files/patch-matrix.cpp =================================================================== RCS file: files/patch-matrix.cpp diff -N files/patch-matrix.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-matrix.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,377 @@ +--- 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::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::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; im[(i+rw)*this->cols()+cl]-1 ; + for ( j = 0; j < a.cols(); ++j) + *(++pptr) = *(++aptr); + } +@@ -208,7 +208,7 @@ + Matrix Matrix::get(int rw, int cl, int nr, int nc) const + { + Matrix 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;irows();++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 + Vector Matrix::getDiag(){ + int i, iend; +- Vector vec(minimum(rows(),cols())) ; +- iend = minimum(rows(),cols()); ++ Vector 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& Matrix::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& Matrix::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& Matrix::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& Matrix::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 + Matrix& Matrix::operator+=(const Matrix &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::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 + Matrix& Matrix::operator-=(const Matrix &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::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 + T Matrix::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 + Matrix Matrix::herm() const + { +- int i, j, r = cols(), c = rows(); ++ int i, j, r = this->cols(), c = this->rows(); + Matrix 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 + Matrix Matrix::flop() const + { +- Matrix f(rows(),cols()) ; +- for(int i=rows()-1;i>=0;--i) +- for(int j=cols()-1;j>=0;--j) ++ Matrix 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 + int i, j; +- const int& r = cols(); +- const int& c = rows(); ++ const int& r = this->cols(); ++ const int& c = this->rows(); + Matrix 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::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::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; + } + Index: files/patch-matrixMat.cpp =================================================================== RCS file: files/patch-matrixMat.cpp diff -N files/patch-matrixMat.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-matrixMat.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,119 @@ +--- 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 + LUMatrix& LUMatrix::operator=(const LUMatrix& a){ + resize(a.rows(),a.cols()) ; +- for(int i=0;irows();++i) ++ for(int j=0;jcols();++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;ielem(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 + T LUMatrix::determinant(){ +- T det = elem(0,0) ; +- for(int i=1;ielem(0,0) ; ++ for(int i=1;irows();++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 + Matrix LUMatrix::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 + } Index: files/patch-matrixRT.cpp =================================================================== RCS file: files/patch-matrixRT.cpp diff -N files/patch-matrixRT.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-matrixRT.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,213 @@ +--- 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 + MatrixRT::MatrixRT() : Matrix(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 + MatrixRT& MatrixRT::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 + MatrixRT& MatrixRT::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 + MatrixRT& MatrixRT::operator=(const MatrixRT& M) { + T *a,*b ; +- a = m-1 ; ++ a = this->m-1 ; + b = M.m - 1 ; + for(int i=0;i<16;++i){ + *(++a) = *(++b) ; Index: files/patch-nurbs.cpp =================================================================== RCS file: files/patch-nurbs.cpp diff -N files/patch-nurbs.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbs.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,42 @@ +--- 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 + #include "integrate.h" + +-#include ++#include + + /*! + */ +@@ -391,9 +391,9 @@ + T du,dv ; + // compute a coarse distance for the curve + Point_nD 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 + BasicList > NurbsCurve::tesselate(T tolerance,BasicList *uk) const { +- BasicList > list,list2 ; ++ BasicList > list, list2 ; + + NurbsCurveArray ca ; + decompose(ca) ; +@@ -5249,7 +5249,7 @@ + } + else{ + for(int i=0;i >*)list.last()) ; Index: files/patch-nurbsS.cpp =================================================================== RCS file: files/patch-nurbsS.cpp diff -N files/patch-nurbsS.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbsS.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,68 @@ +--- 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 ++#include + #endif + + /*! +@@ -3762,12 +3762,12 @@ + // we use and angle of 36 to view the object + // and position the rest according to this. + Point_nD 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 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 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 lookAt ; + lookAt.x() = (minP.x()+maxP.x())/2.0 ; +@@ -4045,12 +4045,12 @@ + } + + Point_nD 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 lookAt ; + lookAt.x() = (minP.x()+maxP.x())/2.0 ; Index: files/patch-nurbsS_sp.cpp =================================================================== RCS file: files/patch-nurbsS_sp.cpp diff -N files/patch-nurbsS_sp.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbsS_sp.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,196 @@ +--- 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 + void NurbsSurfaceSP::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;iP.rows()) ; ++ maxAtU_.resize(this->P.rows()) ; ++ for(int i=0;iP.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 + void NurbsSurfaceSP::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;iP.cols()) ; ++ maxAtV_.resize(this->P.cols()) ; ++ for(int i=0;iP.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 NurbsSurfaceSP::generateParallel(T d) const { + NurbsSurfaceSP p(*this) ; + +- Vector< Point_nD > offset(P.rows()*P.cols()) ; +- Vector ur(P.rows()*P.cols()) ; +- Vector vr(P.rows()*P.cols()) ; +- Vector_INT Du(P.rows()*P.cols()) ; +- Vector_INT Dv(P.rows()*P.cols()) ; ++ Vector< Point_nD > offset(this->P.rows()*this->P.cols()) ; ++ Vector ur(this->P.rows()*this->P.cols()) ; ++ Vector 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;iP.rows();++i) ++ for(j=0;jP.cols();++j){ + Point_nD 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(v2this->V[this->V.n()-1]) v1 = this->V[this->V.n()-1] ; ++ if(v2V[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] ; +- if(u2 > U[U.n()-1]) u2 = U[U.n()-1] ; ++ if(u1 < this->U[0]) u1 = this->U[0] ; ++ if(u2 > this->U[this->U.n()-1]) u2 = this->U[this->U.n()-1] ; + + T u3,v3 ; + u3 = maxAtU_[i] ; +@@ -212,8 +212,8 @@ + else + v3 = maxAtV_[j]- nt*delta ; + +- if(v3V[V.n()-1]) v3 = V[V.n()-1] ; ++ if(v3V[0]) v3 = this->V[0] ; ++ if(v3>this->V[this->V.n()-1]) v3 = this->V[this->V.n()-1] ; + + norm = normal(u1,v1); + norm += normal(u2,v2) ; +@@ -263,13 +263,13 @@ + + 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 u(sizeU) ; + Vector v(sizeV) ; +@@ -280,16 +280,16 @@ + int n=0; + int nu = 0 ; + int nv = 0 ; +- for(int k=i-degU-1;k<=i+degU+1;++k){ ++ for(int 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() ; Index: files/patch-nurbsS_sp.h =================================================================== RCS file: files/patch-nurbsS_sp.h diff -N files/patch-nurbsS_sp.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbsS_sp.h 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,11 @@ +--- nurbs/nurbsS_sp.h.orig Mon May 13 14:07:46 2002 ++++ nurbs/nurbsS_sp.h Fri Dec 1 00:48:44 2006 +@@ -78,7 +78,7 @@ + + + void modSurfCPby(int i, int j, const HPoint_nD& a) //!< Moves a surface point by a value +- { P(i,j) += a / (maxU[i]*maxV[j]) ; } ++ { this->P(i,j) += a / (maxU[i]*maxV[j]) ; } + void modSurfCP(int i, int j, const HPoint_nD& a) //!< Moves a surface point to a value + { modSurfCPby(i,j,a-surfP(i,j)) ; } + Index: files/patch-nurbsSub.cpp =================================================================== RCS file: files/patch-nurbsSub.cpp diff -N files/patch-nurbsSub.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbsSub.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,20 @@ +--- nurbs/nurbsSub.cpp.orig Mon May 13 14:07:46 2002 ++++ nurbs/nurbsSub.cpp Fri Dec 1 01:04:05 2006 +@@ -904,7 +904,7 @@ + + /* Allocate storage for the grid of points generated */ + +- CHECK( pts = new (SurfSample*)[Granularity+1]); ++ CHECK( pts = new SurfSample* [Granularity+1]); + CHECK( pts[0] = new SurfSample[(Granularity+1)*(Granularity+1)]); + + for (i = 1; i <= Granularity; i++) +@@ -983,7 +983,7 @@ + + if (! *alpha) /* Must allocate alpha */ + { +- CHECK( *alpha = new (T*)[k+1]); ++ CHECK( *alpha = new T* [k+1]); + for (i = 0; i <= k; i++) + CHECK( (*alpha)[i] = new T[(m + n + 1)]); + } Index: files/patch-nurbs_sp.cpp =================================================================== RCS file: files/patch-nurbs_sp.cpp diff -N files/patch-nurbs_sp.cpp --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-nurbs_sp.cpp 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,62 @@ +--- nurbs/nurbs_sp.cpp.orig Mon May 13 14:07:46 2002 ++++ nurbs/nurbs_sp.cpp Fri Dec 1 00:46:20 2006 +@@ -41,7 +41,7 @@ + */ + template + void NurbsCurveSP::updateMaxU() { +- if(deg_>3){ ++ if(this->deg_>3){ + #ifdef USE_EXCEPTION + throw NurbsInputError(); + #else +@@ -51,10 +51,10 @@ + #endif + } + else{ +- maxU.resize(P.n()) ; +- maxAt_.resize(P.n()) ; +- for(int i=0;iP.n()) ; ++ maxAt_.resize(this->P.n()) ; ++ for(int i=0;iP.n();++i){ ++ if(!maxInfluence(i,this->U,this->deg_,maxAt_[i])) + cerr << "Problem in maxInfluence U!\n" ; + if(i>0) + if(maxAt_[i]::operator+=(Vector&)"); +- error << "Vector a += Vector b different sizes, a = " << size() << ", b = " << a.size() ; ++ error << "Vector a += Vector b different sizes, a = " << this->size() << ", b = " << a.size() ; + error.fatal() ; + #endif + } +- const int sz = size(); ++ const int sz = this->size(); + T *ptr,*aptr ; +- ptr = x-1 ; ++ ptr = this->x-1 ; + aptr = a.x-1 ; + for (int i = sz; i >0; --i) + *(++ptr) += *(++aptr) ; +@@ -165,20 +165,20 @@ + template + Vector& Vector::operator-=(const Vector &a) + { +- if ( a.size() != size()) ++ if ( a.size() != this->size()) + { + #ifdef USE_EXCEPTION +- throw WrongSize(size(),a.size()) ; ++ throw WrongSize(this->size(),a.size()) ; + #else + Error error("Vector::operator-=(Vector&)"); +- error << "Vector a -= Vector b different sizes, a = " << size() << ", b = " << a.size() ; ++ error << "Vector a -= Vector b different sizes, a = " << this->size() << ", b = " << a.size() ; + error.fatal() ; + #endif + } + +- const int sz = size(); ++ const int sz = this->size(); + T *ptr,*aptr ; +- ptr = x-1 ; ++ ptr = this->x-1 ; + aptr = a.x-1 ; + for (int i = sz; i > 0; --i) + *(++ptr) -= *(++aptr) ; +@@ -391,7 +391,7 @@ + } + + T *aptr,*bptr ; +- aptr = &x[i]-1 ; ++ aptr = &this->x[i]-1 ; + bptr = b.x-1 ; + for ( int j = b.rows(); j > 0; --j) + *(++aptr) = *(++bptr) ; +@@ -429,7 +429,7 @@ + + Vector subvec(l) ; + T *aptr, *bptr ; +- aptr = &x[i] - 1 ; ++ aptr = &this->x[i] - 1 ; + bptr = subvec.x -1 ; + for ( int j = l; j > 0; --j) + *(++bptr) = *(++aptr) ; +@@ -449,12 +449,12 @@ + */ + template + int Vector::minIndex() const { +- T min = x[0] ; ++ T min = this->x[0] ; + int index = 0 ; + +- for(int i=1;in();i++){ ++ if(this->x[i]<=min){ ++ min = this->x[i] ; + index = i ; + } + } +@@ -523,12 +523,12 @@ + T a ; + T *v1,*v2 ; + +- ir = sze-1 ; ++ ir = this->sze-1 ; + l = 0 ; + + while(1){ + if(ir-lx[l] ; + for(j=l+1;j<=ir;++j){ + a = *(++v1) ; + v2 = v1 ; +@@ -547,31 +547,31 @@ + } + else{ + k=(l+ir) >> 1 ; +- swap(x[k],x[l+1]) ; +- if(x[l+1] > x[ir]){ +- swap(x[l+1],x[ir]) ; ++ swap(this->x[k],this->x[l+1]) ; ++ if(this->x[l+1] > this->x[ir]){ ++ swap(this->x[l+1],this->x[ir]) ; + } +- if(x[l]> x[ir]){ +- swap(x[l],x[ir]) ; ++ if(this->x[l]> this->x[ir]){ ++ swap(this->x[l],this->x[ir]) ; + } +- if(x[l+1] > x[l]){ +- swap(x[l+1],x[l]) ; ++ if(this->x[l+1] > this->x[l]){ ++ swap(this->x[l+1],this->x[l]) ; + } + i=l+1 ; + j=ir ; +- a=x[l] ; +- v1 = &x[i] ; +- v2 = &x[j] ; ++ a=this->x[l] ; ++ v1 = &this->x[i] ; ++ v2 = &this->x[j] ; + while(1){ + while(*v1 < a) { ++i ; ++v1 ; } + while(*v2 > a) { --j ; --v2 ; } + if(jx[i],this->x[j]) ; + } +- x[l] = x[j] ; +- x[j] = a ; ++ this->x[l] = this->x[j] ; ++ this->x[j] = a ; + jstack += 2 ; + if(jstack>=Nstack){ + istack.resize(istack.n()+Nstack) ; // increase the vector size +@@ -618,10 +618,10 @@ + int jstack=0; + T a ; + +- ir = sze-1 ; ++ ir = this->sze-1 ; + l = 0 ; + +- index.resize(sze) ; ++ index.resize(this->sze) ; + for(i=0;ix[indext] ; + for(i=j-1;i>=0;--i){ +- if(x[index[i]] <= a) break ; ++ if(this->x[index[i]] <= a) break ; + index[i+1] = index[i] ; + } + index[i+1] = indext ; +@@ -643,24 +643,24 @@ + else{ + k=(l+ir) >> 1 ; + swap(index[k],index[l+1]) ; +- if(x[index[l+1]] > x[index[ir]]){ ++ if(this->x[index[l+1]] > this->x[index[ir]]){ + swap(index[l+1],index[ir]) ; + } +- if(x[index[l]]> x[index[ir]]){ ++ if(this->x[index[l]]> this->x[index[ir]]){ + swap(index[l],index[ir]) ; + } +- if(x[index[l+1]] > x[index[l]]){ ++ if(this->x[index[l+1]] > this->x[index[l]]){ + swap(index[l+1],index[l]) ; + } + i=l+1 ; + j=ir ; + indext = index[l] ; +- a=x[indext] ; ++ a=this->x[indext] ; + while(1){ +- while(x[index[i]] < a) { ++i ; } +- while(x[index[j]] > a) { --j ; } ++ while(this->x[index[i]] < a) { ++i ; } ++ while(this->x[index[j]] > a) { --j ; } + if(jx[index[i]] == this->x[index[j]]) + break ; + swap(index[i],index[j]) ; + } Index: files/patch-vector.h =================================================================== RCS file: files/patch-vector.h diff -N files/patch-vector.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ files/patch-vector.h 1 Dec 2006 09:19:00 -0000 @@ -0,0 +1,11 @@ +--- matrix/vector.h.orig Mon May 13 14:07:45 2002 ++++ matrix/vector.h Thu Nov 30 23:29:02 2006 +@@ -69,7 +69,7 @@ + { + public: + int rows() const //!< a reference to the size of the vector +- { return sze ;} ++ { return this->sze ;} + Vector() : BasicArray(1) {} //!< Basic constructor + Vector(const int r) : BasicArray(r) {} + Vector(const Vector& v) : BasicArray(v) {} --- nurbs-unbreak.patch ends here --- >Release-Note: >Audit-Trail: State-Changed-From-To: open->closed State-Changed-By: pav State-Changed-When: Fri Dec 1 09:41:29 UTC 2006 State-Changed-Why: Committed, thanks! http://www.freebsd.org/cgi/query-pr.cgi?pr=106117 From: dfilter@FreeBSD.ORG (dfilter service) To: bug-followup@FreeBSD.org Cc: Subject: Re: ports/106117: commit references a PR Date: Fri, 1 Dec 2006 09:55:38 +0000 (UTC) pav 2006-12-01 09:55:32 UTC FreeBSD ports repository Modified files: graphics/nurbs++ Makefile Added files: graphics/nurbs++/files patch-cvector.h patch-d_nurbsSub.cpp patch-f_nurbsSub.cpp patch-hnurbsS.cpp patch-hnurbsS_sp.cpp patch-image.cpp patch-list.h patch-matrix.cpp patch-matrixMat.cpp patch-matrixRT.cpp patch-nurbs.cpp patch-nurbsS.cpp patch-nurbsS_sp.cpp patch-nurbsS_sp.h patch-nurbsSub.cpp patch-nurbs_sp.cpp patch-nurbs_sp.h patch-vector.cpp patch-vector.h Log: - Unbreak on 5.X and above: fix compile with gcc34 PR: ports/106117 Submitted by: Peter Johnson Revision Changes Path 1.17 +2 -12 ports/graphics/nurbs++/Makefile 1.1 +16 -0 ports/graphics/nurbs++/files/patch-cvector.h (new) 1.1 +13 -0 ports/graphics/nurbs++/files/patch-d_nurbsSub.cpp (new) 1.1 +13 -0 ports/graphics/nurbs++/files/patch-f_nurbsSub.cpp (new) 1.1 +381 -0 ports/graphics/nurbs++/files/patch-hnurbsS.cpp (new) 1.1 +406 -0 ports/graphics/nurbs++/files/patch-hnurbsS_sp.cpp (new) 1.1 +98 -0 ports/graphics/nurbs++/files/patch-image.cpp (new) 1.1 +10 -0 ports/graphics/nurbs++/files/patch-list.h (new) 1.1 +377 -0 ports/graphics/nurbs++/files/patch-matrix.cpp (new) 1.1 +119 -0 ports/graphics/nurbs++/files/patch-matrixMat.cpp (new) 1.1 +213 -0 ports/graphics/nurbs++/files/patch-matrixRT.cpp (new) 1.1 +42 -0 ports/graphics/nurbs++/files/patch-nurbs.cpp (new) 1.1 +68 -0 ports/graphics/nurbs++/files/patch-nurbsS.cpp (new) 1.1 +196 -0 ports/graphics/nurbs++/files/patch-nurbsS_sp.cpp (new) 1.1 +11 -0 ports/graphics/nurbs++/files/patch-nurbsS_sp.h (new) 1.1 +20 -0 ports/graphics/nurbs++/files/patch-nurbsSub.cpp (new) 1.1 +62 -0 ports/graphics/nurbs++/files/patch-nurbs_sp.cpp (new) 1.1 +11 -0 ports/graphics/nurbs++/files/patch-nurbs_sp.h (new) 1.1 +255 -0 ports/graphics/nurbs++/files/patch-vector.cpp (new) 1.1 +11 -0 ports/graphics/nurbs++/files/patch-vector.h (new) _______________________________________________ cvs-all@freebsd.org mailing list http://lists.freebsd.org/mailman/listinfo/cvs-all To unsubscribe, send any mail to "cvs-all-unsubscribe@freebsd.org" >Unformatted: