//Evaluate right continuous ndu'th and ndv'th derivative data.
//Function's return value is (d(ndu+ndv)f(u,v))/(du**ndu*dv**ndv).
// ndu=0 and ndv=0 means positional data evaluation.
MGVector MGSBRep::eval(
double u, double v, // Parameter value of the surface.
size_t ndu, // Order of Derivative along u.
size_t ndv // Order of Derivative along v.
) const
{
const unsigned ku=order_u(), kv=order_v();
double cu[10],cv[10];
double *cup=cu, *cvp=cv;
if(ku>10) cup=new double[ku]; //This is done to save "new" when ku<=10.
if(kv>10) cvp=new double[kv]; //This is done to save "new" when kv<=10.
const int num1=bdim_u()-1, nvm1=bdim_v()-1;
int idu=m_uknot.eval_coef(u,cup,ndu);
int idv=m_vknot.eval_coef(v,cvp,ndv);
size_t i,j,m; int jj;
const size_t ncd=sdim();
MGVector S(ncd); double coefall,coefu;
for(m=0; m<ncd; m++){
coefall=0.;
for(j=0;j<kv;j++){
coefu=0.;
jj=idv+j;
for(i=0;i<ku;i++) coefu=coefu+coef(idu+i,jj,m)*cup[i];
coefall=coefall+coefu*cvp[j];
}
S.set(m)=coefall;
}
if(ku>10) delete[] cup; if(kv>10) delete[] cvp;
return S;
}
// 論理演算子の多重定義
// 与曲線と自身が等しいかの比較判定を行う。
//RSB and SB comparison.
bool MGRSBRep::operator==(const MGSBRep& sb)const{
if(sdim()!=sb.sdim())
return 0;//Check of space dimension.
if(order_u()!=sb.order_u())
return 0; //Check of order.
if(order_v()!=sb.order_v())
return 0; //Check of order.
size_t bdu=bdim_u(), bdv=bdim_v();
if(bdu!=sb.bdim_u())
return 0; //Check of B-Rep dimension.
if(bdv!=sb.bdim_v())
return 0; //Check of B-Rep dimension.
if(bdu<=0 && bdv<=0)
return 1;
if(!non_rational())
return 0; //Check of rationality.
if(knot_vector_u() != sb.knot_vector_u())
return 0;//Check of knot vector.
if(knot_vector_v() != sb.knot_vector_v())
return 0;//Check of knot vector.
//Finally, check of control polygon.
return m_surface.surface_bcoef().non_homogeneous()==sb.surface_bcoef();
}
MGSBRep& MGSBRep::refine( //BSUNK
const MGKnotVector& uknot, // knot of u-direction
const MGKnotVector& vknot) // knot of v-direction
//Change an original B-Rep to new one with subdivided knot configuration.
//Knots t must be subdivided knots.
{
int refine_kind;
if(uknot!=m_uknot){
if(vknot!=m_vknot) refine_kind=3;
else refine_kind=1;
}else if(vknot!=m_vknot) refine_kind=2;
else return *this;
// refine_kind=1:u-knot only, =2:v-knot only, =3:both u and v-knot.
unsigned ku=order_u(); size_t lud=bdim_u();
unsigned kv=order_v(); size_t lvd=bdim_v();
size_t is1,is2; surface_bcoef().capacity(is1,is2);
size_t lud2=uknot.bdim(), lvd2=vknot.bdim();
MGSPointSeq bcoef(lud2,lvd2,3);
unsigned k=ku; if(k<kv) k=kv;
double* work1=new double[k*k];
double* work2=new double[lvd2*2];
bsunk_(refine_kind,ku,lud,knot_data_u(),kv,lvd,knot_data_v(),coef_data(),
is1,is2,lud2,uknot.data(),lvd2,vknot.data(),
lud2,lvd2,work1,work2,&bcoef(0,0,0));
delete[] work1; delete[] work2;
m_uknot=uknot; m_vknot=vknot;
m_surface_bcoef=bcoef;
update_mark();
return *this;
}
bool MGRSBRep::operator==(const MGRSBRep& rsb2)const{
size_t sd1=sdim(), sd2=rsb2.sdim();
if(sd1!=sd2)
return 0;
if(order_u()!=rsb2.order_u())
return 0; //Check of order.
if(order_v()!=rsb2.order_v())
return 0; //Check of order.
size_t bdu1=bdim_u(), bdu2=rsb2.bdim_u();
if(bdu1!=bdu2)
return 0;
size_t bdv1=bdim_v(), bdv2=rsb2.bdim_v();
if(bdv1!=bdv2)
return 0;
if(bdu1<=0 && bdv1<=0)
return 1;
if(knot_vector_u() != rsb2.knot_vector_u())
return 0;
if(knot_vector_v() != rsb2.knot_vector_v())
return 0;
double ratio=rsb2.coef(0,0,sd2)/coef(0,0,sd1);
//Check if weights are equal.
for(size_t i=0; i<bdu1; i++)
for(size_t j=0; j<bdv1; j++)
if(!MGREqual2(ratio,rsb2.coef(i,j,sd2)/coef(i,j,sd1)))
return 0;
return m_surface.surface_bcoef().non_homogeneous()
==rsb2.m_surface.surface_bcoef().non_homogeneous() ;
}
int MGSBRep::reduce( //BSUDEC
int is_u, //if true, reduce b-rep dimension of u-direction.
int ndec) //Number of B-rep dimension to decrease
//Change the B-Rep by decreasing B-Rep dimension by ndec. This is
//an approximation of the original B-Rep. Return value is error flag.
{
assert(ndec>=0);
if(is_u) assert(bdim_u()-ndec>=order_u());
else assert(bdim_v()-ndec>=order_v());
if(ndec<=0) return 0;
size_t kdec=2; if(is_u) kdec=1;
unsigned ku=order_u(); size_t lud=bdim_u();
unsigned kv=order_v(); size_t lvd=bdim_v();
unsigned maxlen=lud; if(maxlen<lvd) maxlen=lvd;
size_t is1,is2; surface_bcoef().capacity(is1,is2);
int lud2, lvd2;
MGKnotVector tu(ku,lud), tv(kv,lvd);
MGSPointSeq bcoef(lud,lvd,3);
int iflag;
unsigned k=ku; if(k<kv) k=kv;
double* work1=new double[maxlen*(2*k-1)];
double* work2=new double[maxlen];
double* work3=new double[lvd*2];
bsudec_(
ku,lud,knot_data_u(),kv,lvd,knot_data_v(),coef_data(),
kdec,ndec,is1,is2,lud,lvd,work1,work2,work3,
&lud2,&tu(0),&lvd2,&tv(0),&bcoef(0,0,0),&iflag);
if(iflag==1){
tu.set_bdim(lud2); tv.set_bdim(lvd2);
m_uknot=tu; m_vknot=tv;
bcoef.set_length(lud2,lvd2);
m_surface_bcoef=bcoef;
iflag=0;
}
delete[] work1; delete[] work2; delete[] work3;
update_mark();
return iflag;
}
//Evaluate right continuous surface data.
//Evaluate all positional data, 1st and 2nd derivatives.
void MGSBRep::eval_all(
double u, double v, // Parameter value of the surface.
MGPosition& f, // Positional data.
MGVector& fu, // df(u,v)/du
MGVector& fv, // df/dv
MGVector& fuv, // d**2f/(du*dv)
MGVector& fuu, // d**2f/(du**2)
MGVector& fvv // d**2f/(dv**2)
) const
{
size_t ku=order_u(), kv=order_v();
size_t ku2=ku+ku, kv2=kv+kv;
double *ucoef=new double[ku*3], *vcoef=new double[kv*3];
int bdum1=bdim_u()-1, bdvm1=bdim_v()-1;
int uid=m_uknot.eval_coef(u,ucoef,0);
int vid=m_vknot.eval_coef(v,vcoef,0);
m_uknot.eval_coef(u,ucoef+ku,1); m_uknot.eval_coef(u,ucoef+ku2,2);
m_vknot.eval_coef(v,vcoef+kv,1); m_vknot.eval_coef(v,vcoef+kv2,2);
double s,su,suu,c,vj,vj1; size_t i,j,k,dim=sdim();
int ii,jj;
MGPosition p(dim);
MGVector pu(dim),pv(dim),puv(dim),puu(dim),pvv(dim);
for(k=0; k<dim; k++){
p(k)=0.0;pu.set(k)=0.0;pv.set(k)=0.0;puv.set(k)=0.0;
puu.set(k)=0.0;pvv.set(k)=0.0;
for(j=0; j<kv; j++){
s=su=suu=0.0;
jj=vid+j;
for(i=0; i<ku; i++){
ii=uid+i;
c=coef(ii,jj,k);
s=s+ucoef[i]*c;
su=su+ucoef[i+ku]*c;
suu=suu+ucoef[i+ku2]*c;
}
vj=vcoef[j]; vj1=vcoef[j+kv];
p(k)=p(k)+vj*s;
pu.set(k)=pu.ref(k)+vj*su;
pv.set(k)=pv.ref(k)+vj1*s;
puv.set(k)=puv.ref(k)+vj1*su;
puu.set(k)=puu.ref(k)+vj*suu;
pvv.set(k)=pvv.ref(k)+vcoef[j+kv2]*s;
}
}
f=p;fu=pu;fv=pv;fuv=puv;fuu=puu;fvv=pvv;
delete[] ucoef; delete[] vcoef;
}
//Evaluate all of derivative data (d(i+j)f(u,v))/(du**i*dv**j),
//for 0<=i<=ndu and 0<=j<=ndv.
void MGSBRep::eval_all(
double u, double v, // Parameter value of the surface.
size_t ndu, //Order of Derivative along u.
size_t ndv, //Order of Derivative along v.
double* deriv //Output. (d(i+j)f(u,v))/(du**i*dv**j) in
//deriv[r+j*dim+i*(ndv+1)*dim] for 0<=r<dim=sdim().
//for 0<=i<=ndu and 0<=j<=ndv.
//deriv is an array of deriv[ndu+1][ndv+1][r],
//(d(i+j)f(u,v))/(du**i*dv**j) is returned in deriv[i][j][r].
) const{
size_t i,j,jj,r, dim=sdim();
size_t ider,jder;
const unsigned ku=order_u(), kv=order_v();
size_t kundu=ku*(ndu+1), kvndv=kv*(ndv+1);
double cu[30],cv[30]; double *cup=cu, *cvp=cv;
if(kundu>30) cup=new double[kundu]; //Done to save "new".
if(kvndv>30) cvp=new double[kvndv]; //Done to save "new".
int idu,idv;
for(ider=0; ider<=ndu; ider++) idu=m_uknot.eval_coef(u,cup+ider*ku,ider);
for(jder=0; jder<=ndv; jder++) idv=m_vknot.eval_coef(v,cvp+jder*kv,jder);
double coefall,coefu;
for(ider=0; ider<=ndu;ider++){
size_t iderndv1dim=ider*(ndv+1)*dim;
for(jder=0; jder<=ndv; jder++){
size_t jderdim=jder*dim;
for(r=0; r<dim; r++){
coefall=0.;
for(j=0;j<kv;j++){
coefu=0.;
jj=idv+j;
for(i=0;i<ku;i++)
coefu=coefu+coef(idu+i,jj,r)*cup[i+ider*ku];
coefall=coefall+coefu*cvp[j+jder*kv];
}
deriv[r+jderdim+iderndv1dim]=coefall;
}
}
}
if(kundu>30) delete[] cup;
if(kvndv>30) delete[] cvp;
}
// Compute parameter line.
MGLBRep MGSBRep::parameter_line(
int is_u //Indicates x is u-value if is_u is true.
, double x //Parameter value.
//The value is u or v according to is_u.
, unsigned nderiv //Order of derivative.
)const{
unsigned ku=order_u(); size_t lud=bdim_u();
unsigned kv=order_v(); size_t lvd=bdim_v();
size_t is1,is2; surface_bcoef().capacity(is1,is2);
size_t ncd=sdim(), len;
int kx; int k;
if(is_u){ kx=1; len=lvd; k=kv; }
else { kx=0; len=lud; k=ku; }
MGLBRep lb(len,k,ncd);
MGBPointSeq& rcoef=lb.line_bcoef();
MGKnotVector& t=lb.knot_vector();
int n;
bsepl_(ku,lud,knot_data_u(),kv,lvd,knot_data_v(),coef_data(),
is1,is2,ncd,kx,x,nderiv,len,&k,&n,&t(0),&rcoef(0,0));
return lb;
}
typename beziervolume<point_t>::array_type
beziervolume<point_t>::ocsplit ( ) const
{
array_type result;
std::size_t new_size_u = order_u() + degree_u();
std::size_t new_size_v = order_v() + degree_v();
std::size_t new_size_w = order_w() + degree_w();
// generate point-meshes for different steps of split
pointmesh3d<point_t> cpsplit_u ( new_size_u, order_v(), order_w() );
pointmesh3d<point_t> cpsplit_uv ( new_size_u, new_size_v, order_w() );
pointmesh3d<point_t> cpsplit_uvw ( new_size_u, new_size_v, new_size_w );
converter<point_t> converter;
// split in u
for (std::size_t v = 0; v != order_v(); ++v)
{
for (std::size_t w = 0; w != order_w(); ++w)
{
// elevate to virtual nurbscurve to apply knot insertion
std::vector<point_t> tmp_curve = _points.submesh ( 0, v, w );
// create knot vector
std::vector<value_type> kv_min (order_u(), 0);
std::vector<value_type> kv_max (order_u(), 1);
std::multiset<value_type> kv;
kv.insert ( kv_min.begin(), kv_min.end() );
kv.insert ( kv_max.begin(), kv_max.end() );
converter.knot_insertion (tmp_curve, kv, order_u(), value_type(0.5));
cpsplit_u.submesh (tmp_curve.begin(), 0, v, w);
}
}
// split in v
for (std::size_t u = 0; u != new_size_u; ++u)
{
for (std::size_t w = 0; w != order_w(); ++w)
{
// elevate to virtual nurbscurve to apply knot insertion
std::vector<point_t> tmp_curve = cpsplit_u.submesh ( 1, u, w );
// create knot vector
std::vector<value_type> kv_min (order_v(), 0);
std::vector<value_type> kv_max (order_v(), 1);
std::multiset<value_type> kv;
kv.insert ( kv_min.begin(), kv_min.end() );
kv.insert ( kv_max.begin(), kv_max.end() );
converter.knot_insertion (tmp_curve, kv, order_v(), value_type(0.5));
cpsplit_uv.submesh (tmp_curve.begin(), 1, u, w);
}
}
// split in w
for (std::size_t u = 0; u != new_size_u; ++u)
{
for (std::size_t v = 0; v != new_size_v; ++v)
{
// elevate to virtual nurbscurve to apply knot insertion
std::vector<point_t> tmp_curve = cpsplit_uv.submesh ( 2, u, v );
// create knot vector
std::vector<value_type> kv_min (order_w(), 0);
std::vector<value_type> kv_max (order_w(), 1);
std::multiset<value_type> kv;
kv.insert ( kv_min.begin(), kv_min.end() );
kv.insert ( kv_max.begin(), kv_max.end() );
converter.knot_insertion (tmp_curve, kv, order_w(), value_type(0.5));
cpsplit_uvw.submesh (tmp_curve.begin(), 2, u, v);
}
}
// generate subvolumes
for (std::size_t w = 0; w != 2; ++w)
{
for (std::size_t v = 0; v != 2; ++v)
{
for (std::size_t u = 0; u != 2; ++u)
{
pointmesh3d<point_t> submesh = cpsplit_uvw.submesh(u*degree_u(), v*degree_v(), w*degree_w(), order_u(), order_v(), order_w());
beziervolume subvolume (submesh);
//result[array_index(u)][array_index(v)][array_index(w)] = subvolume;
result[u][v][w] = subvolume;
}
}
}
return result;
}
//Modify the original Surface by extrapolating the specified perimeter.
//The extrapolation is C2 continuous if the order >=4.
//The extrapolation is done so that extrapolating length is "length"
//at the position of the parameter value "param" of the perimeter.
MGRSBRep& MGRSBRep::extend(
int perimeter, //perimeter number of the Surface.
// =0:v=min, =1:u=max, =2:v=max, =3:u=min.
double param, // parameter value of above perimeter.
double length, //chord length to extend at the parameter param of the perimeter.
double dk){ //Coefficient of how curvature should vary at
// extrapolation start point. When dk=0, curvature keeps same, i.e.
// dK/dS=0. When dk=1, curvature becomes zero at length extrapolated point,
// i.e. dK/dS=-K/length at extrapolation start point.
// (S=parameter of arc length, K=Curvature at start point)
// That is, when dk reaches to 1 from 0, curve changes to flat.
assert(sdim()<=3);
assert(perimeter>=0 && perimeter<4);
const size_t ncd=surface_bcoef().sdim();
int at_start=1;//starting perimeter
size_t nu, nv;
size_t order; size_t n,m; MGKnotVector* t;
if(perimeter==1 || perimeter==3){ // Extrapolate to u-direction
order=order_u();
n=bdim_u();
t=&(knot_vector_u());
if(perimeter==1)
at_start=0;//ending perimeter
m=nv=bdim_v();
}else{
// Extrapolate to v-direction
order=order_v();
n=bdim_v();
t=&(knot_vector_v());
if(perimeter==2)
at_start=0;//ending perimeter
m=nu=bdim_u();
}
//(nu,nv) are new surface B-Rep dimensions of u and v.
//(order,n,t) is line B-rep to extrapolate.
//m is the number of line B-reps to extrapolate.
MGSPointSeq surf;
MGRLBRep lbtemp;
MGKnotVector& t1=lbtemp.knot_vector();
MGBPointSeq& coeftemp=lbtemp.line_bcoef();
coeftemp.resize(n,ncd);
double tse;
if(at_start)
tse=t->param_s();
else
tse=t->param_e();
MGPosition uv=perimeter_uv(perimeter,param);//Surface parameter value of param.
size_t ndu=0,ndv=0;
if(perimeter==0 || perimeter==2) ndv=1;
else ndu=1;
double slen=length/(eval(uv,ndu,ndv)).len();
int nnew; double firstd_len,dlen;
for(size_t i=0; i<m; i++){
if(perimeter==0 || perimeter==2){
for(size_t j=0; j<n; j++)
for(size_t k=0; k<ncd; k++) coeftemp(j,k)=coef(i,j,k);
}else{
for(size_t j=0; j<n; j++)
for(size_t k=0; k<ncd; k++) coeftemp(j,k)=coef(j,i,k);
}
coeftemp.set_length(n);
//Compute first derivative length at the end of the extrapolating line.
t1=*t;
firstd_len=lbtemp.eval(tse,1).len();
dlen=firstd_len*slen;
//std::cout<<"before:"<<lbtemp<<std::endl;///////
lbtemp.extend(at_start,dlen,dk);
//std::cout<<"after:"<<lbtemp<<std::endl;///////
nnew=lbtemp.bdim();
if(perimeter==0 || perimeter==2){
if(i==0){
nv=nnew;
surf.resize(nu,nv,ncd);
}
for(int j=0; j<nnew; j++)
for(size_t k=0; k<ncd; k++) surf(i,j,k)=coeftemp(j,k);
}else{
if(i==0){
nu=nnew;
surf.resize(nu,nv,ncd);
}
for(int j=0; j<nnew; j++)
for(size_t k=0; k<ncd; k++) surf(j,i,k)=coeftemp(j,k);
}
}
*t=t1;
surf.set_length(nu,nv);
surface_bcoef()=surf;
update_mark();
return *this;
}
inline bool
beziervolume<point_t>::valid ( ) const
{
return (_points.size() == order_u() + order_v());
}
DEM typ1 (DEM x)
{
int o, o1, o2;
DEM a, b, c, c1, f, x1, y, z, v, PIab, bz, s, tf, tf1, tz, tz1, t, n, n1, r;
#if 1
return U(Order(0));
#else
o = order(x);
o1 = suc_order(o);
o2 = suc_order(o1);
switch (node(x))
{
case _Var : return subdem(0,x);
case _It:
a = subdem(0,x);
t = Fott (o1, a, a);
return t;
case _IT :
a = Var ("a", U(o1));
return PIott (o2, U(o1), lambda (a,
Fott (/*suc_order*/(o1), a, a) ));
case _Kt:
a = subdem(0,x);
b = subdem(1,x);
t = Fott (o1, a, Fott (o1, b, a));
return t;
case _KT :
a = Var ("a", U(o1));
b = Var ("b", U(o1));
return PIott (o2, U(o1), lambda (a,
PIott (o2, U(o1), lambda(b,
Fott (o1, a, Fott (o1, b, a)) )) ));
case _St:
a = subdem(0,x);
b = subdem(1,x);
c = subdem(2,x);
z = Var ("z", a);
y = Var ("y", PIott (o1, a, b));
t = Fott (o1, PIott (o1, a, lambda (z,
PIott(o1, ap(b,z),ap(c,z)))),
PIott (o1, PIott (o1, a, b), lambda (y,
Fott (o1, a, ap(ap(c,z),ap(y,z)))) ));
return t;
case _ST :
a = Var ("a", U(o1));
b = Var ("b", Fott (o2, a, U(o1)));
z = Var ("z", a);
c = Var ("c", PIott (o1, a, lambda (z, Fott (o2, ap(b,z), U(o1)))));
y = Var ("y", PIott (o1, a, b));
return PIott (o2, U(o1), lambda (a,
Fott (o2, Fott (o2, a, U(o1)), lambda (b,
PIott (o1, PIott (o1, a, lambda (z,
Fott (o2, ap(b,z), U(o1)))), lambda (c,
Fott (o1, PIott (o1, a, lambda (z,
PIott(o1, ap(b,z),ap(c,z)))),
PIott (o1, PIott (o1, a, b), lambda (y,
Fott (o1, a, ap(ap(c,z),ap(y,z)))) )))
) ))));
case _Yt:
a = subdem(0,x);
t = Fott (o1, Fott (o1, a, a), a);
return t;
case _Ord:
return U(Order(1));
case _Zero:
return Ord;
case _Suc:
return Fott (Order(1), Ord, Ord);
case _Lim:
return Fott (Order(1), Fott (Order(1), Ord, Ord), Ord);
case _Rept:
o1 = Order(1);
a = subdem(0,x);
t = Fott (o1, Ord,
Fott (o1, Fott (o1, a, a), Fott (o1, a, a)));
return t;
case _Testt:
o1 = Order(1);
a = subdem(0,x);
n = Var ("n", Ord);
n1 = Var ("n1", Ord);
t = PIott (o1, Ord, lambda (n1, Fott (o1, ap (a, Zero),
Ftt ( PIott (o1, Ord, lambda (n, ap (a, ap (Suc, n)))),
ap (a, n1) ) )));
return t;
case _F:
return Fott (o1, U(o), Fott (o1, U(o), U(o)));
case _PI:
a = Var ("a", U(o));
return PIott (o1, U(o), lambda (a,
Fott (o1, Fott (o1, a, U(o)), U(o)) ));
case _U: return U (suc_order (order_u (x)));
case _ap:
if (depth(x) == 1 && node(s=rfnc(1,x)) == _Kt)
{
a = subdem(0,s);
b = subdem(1,s);
o = order(s);
return Fott (o, b, a);
}
if (node(subdem(0,x)) == _ap &&
node(subdem(0,subdem(0,x))) == _ap &&
node(subdem(0,subdem(0,subdem(0,x)))) == _KT)
{
a = subdem(1,subdem(0,subdem(0,x)));
b = subdem(1,subdem(0,x));
o = order(a);
return Fott (o, b, a);
}
if (depth (x) == 2 && node(s=rfnc(2,x)) == _St)
{
a = subdem(0,s);
b = subdem(1,s);
c = subdem(2,s);
goto Sabc;
}
if (depth (x) == 5 && node(s=rfnc(5,x)) == _ST)
{
/* S a:Uo+1 b:(Uo(a)+1) c:(a)>\z:a.((bz)>Uo+1)
x:(a)>\z:a.(cz(bz)) y:(a)>b z:a = xz(yz):cz(yz)
xz:(bz)>cz, yz:bz
S a b c x y : a ->> \z:a. cz(yz)
*/
a = subdem(1,rfnc(4,x));
b = subdem(1,rfnc(3,x));
c = subdem(1,rfnc(2,x));
Sabc:
x1 = subdem(1,rfnc(1,x));
y = subdem(1,rfnc(0,x));
z = Var ("z", a);
o = order(s);
o1 = suc_order (o);
/* t = PIott (o1, a, lambda (z, ap (ap (c, z), ap (y, z)))); */
v = Var ("v", simplif (ap (b, z)));
c1 = lambda (z, lambda (v, U(o1)));
trace_dem ("c = ", c);
t = PIott (o1, a, Sotttxx (o, a, b, c1, c, y));
return t;
}
if (node(subdem(0,x)) == _ap &&
node(subdem(0,subdem(0,x))) == _F)
{
/*
if (typ (subdem(1,subdem(0,x))) == typ (subdem(1,x)))
return typ (subdem(1,x));
error ("F applied to different types", __LINE__, x);
*/
return unio (typ(subdem(1,subdem(0,x))),
typ(subdem(1,x)));
}
f = fnc (x);
z = arg (x);
/* PIab = typ (f);
b = arg (PIab); */
tf = typ (f);
tz = typ (z);
new_tz:
print_string (print_param, "typ(z) = ");
print_dem (print_param, tz);
new_tf:
print_string (print_param, " subdem(1,subdem(0,tf)) = ");
print_dem (print_param, subdem(1,subdem(0,tf)));
print_string (print_param, "\n");
if (node(tf) == _ap &&
node(subdem(0,tf)) == _ap &&
node(subdem(0,subdem(0,tf))) == _F &&
inclus (tz, subdem(1,subdem(0,tf))))
return subdem(1,tf);
if (node(tf) == _ap &&
node(subdem(0,tf)) == _ap &&
node(subdem(0,subdem(0,tf))) == _PI &&
inclus (tz, subdem(1,subdem(0,tf))))
{
/* return ap (subdem(1,tf), z); */
tf1 = subdem(1,tf);
print_string (print_param, "tf1 = ");
print_dem (print_param, tf1);
print_string (print_param, "\nz = ");
print_dem (print_param, z);
r = ap (tf1, z);
print_string (print_param, "\nr = ");
print_dem (print_param, r);
print_string (print_param, "\n");
return r;
}
print_string (print_param, "Bad type of function ");
print_dem (print_param, f);
print_string (print_param, " of type ");
print_dem (print_param, tf);
print_string (print_param, " applied to ");
print_dem (print_param, z);
print_string (print_param, " of type ");
print_dem (print_param, tz);
print_string (print_param, "\n");
tf1 = simplif (tf);
if (tf1 != tf)
{
tf = tf1;
goto new_tf;
}
tz1 = simplif (tz);
if (tz1 != tz)
{
tz = tz1;
goto new_tz;
}
print_string (print_param, "Bad type of function ");
print_dem (print_param, f);
print_string (print_param, " of type ");
print_dem (print_param, tf);
print_string (print_param, " applied to ");
print_dem (print_param, z);
print_string (print_param, " of type ");
print_dem (print_param, tz);
print_string (print_param, "\n");
error ("Bad type of function : ", __LINE__, tf);
/*bz = ap (b, z);
return bz;*/
case _Lambda:
z = subdem(0,x);
r = subdem(1,x);
a = typ (z);
bz = typ (r);
b = lambda (z, bz);
t = PItt (a, b);
return t;
break;
default:
print_string (print_param, "typ not implemented for ");
print_dem (print_param, x);
print_string (print_param, "\n");
return U(-1);
}
#endif
}
/* ap (typ_ap(ap(f,x)), x) = typ (ap(f,x)) */
DEM typ_ap (DEM r)
{
DEM a, b, c, u, v, w, bz, cz, PIbzcz, bz1, tf, tf1, r1;
ORDER o, o1;
if (node(r) == _ap)
{
/*
if (subdem(1,r) == z && !in (z, subdem(0,r)))
return subdem(0,r);
a = typ (z);
u = typ (a);
*/
bz = typ (subdem(1,r));
/* b = fnc (bz); */
/* b = lambda (z, bz); */
/*PIbzcz = typ (subdem(0,r));
cz = arg (PIbzcz);*/
tf = typ (subdem(0,r));
new_tf:
if (node(tf) == _ap &&
node(subdem(0,tf)) == _ap)
{
if (node(subdem(0,subdem(0,tf))) == _F)
{
o = order(subdem(0,subdem(0,tf)));
bz1 = subdem(1,subdem(0,tf));
/* cz = Kottx (suc_order(o),*U(o)*/
cz = Kttx (typ(subdem(1,tf)), bz1, subdem(1,tf));
goto re;
}
else if (node(subdem(0,subdem(0,tf))) == _PI)
{
cz = arg (tf);
goto re;
}
}
/* r1 = ap (simplif (subdem(0,r)), subdem(1,r));
if (r1 != r) */
tf1 = simplif (tf);
if (tf1 != tf)
/*return lambda (z, r1);*/
{
tf = tf1;
goto new_tf;
}
/* error ("Bad type of function in lambda", __LINE__, tf); */
return NULL;
/* c = fnc (cz); */
/*c = lambda (z, cz);*/
re:
return cz;
#if 0
c = lambda (z, cz);
o1 = max_order (order_u(u), max_order (order_u(typ(bz)),
order_u(typ(tf)) ));
return Sotttxx (pred_order (o1/*order_u (u)*/), a, b, c,
lambda (z, subdem(0,r)),
lambda (z, subdem(1,r)));
#endif
}
else
{
/* error ("typ_ap : bad ap :", __LINE__, r); */
return NULL;
/*
a = typ (z);
b = typ (r);
u = typ (a);
return Kottx (pred_order (order_u(u)), b, a, r);
*/
}
}
//Test if part of the surface is planar or not within the tolerance tol.
//The part of the surface is input by the surface parameter range uvbox.
//Returned is 0(false) if this is not planar, 1(true) if planar.
int MGSBRep::planar(
const MGBox& uvbox,//This surface parameter range.
double tol, //maximum deviation allowed to regard the sub surface as a plane.
int* divideU//Direction to subdivide will be output, if this was not planar.
//=1: u direction, =0: v direction.
) const{
MGBox uvb=param_range()&uvbox;
MGPosition P;
MGUnit_vector N;
int direction;
if(!flat(uvb,tol,direction,P,N)){
if(divideU) *divideU=direction;
return 0;
};
const MGInterval& urng=uvbox[0];
double u0=urng[0].value(), u1=urng[1].value();
const MGInterval& vrng=uvbox[1];
double v0=vrng[0].value(), v1=vrng[1].value();
double um=(u0+u1)*0.5, vm=(v0+v1)*0.5;
int ncd=sdim();
unsigned ku=order_u(), kv=order_v();
const MGKnotVector& tv=knot_vector_v();
int j0=tv.locate(v0)-kv+1, j1=tv.locate(v1);
//Coef necessary for v direction part is from j0 to j1
//(B-rep dimension is j1-j0+1).
//Knot vector necessary is from j0 to j1+kv.
int nunew, nvnew=j1-j0+1;
tol*=1.1;
size_t nu, nv, sizeu, sizev;
surface_bcoef().length(nu, nv); surface_bcoef().capacity(sizeu, sizev);
unsigned kmax=ku; if(kmax<kv) kmax=kv;
double* work=new double[kmax*kmax];
MGSPointSeq surf1(nvnew, nu, ncd); size_t irc=nvnew*nu;
int nmax=nu; if(nmax<nvnew) nmax=nvnew;
int nvncd=nvnew; if(nvncd<ncd) nvncd=ncd;
MGBPointSeq temp(nmax,nvncd);
MGKnotVector t(kmax, nmax);
double* tpointer=t.data(); double* temppointer=temp.data();
for(int k=0; k<ncd; k++){
double Pk=P[k];
bluprt_(ku, nu, knot_data_u(), coef_data(0,j0,k),
sizeu,nvnew,u0,u1,nmax,work,&nunew,tpointer,temppointer,1);
for(int i=0; i<nunew; i++) for(int j=0; j<nvnew; j++) surf1(j,i,k)=temp(i,j)-Pk;
}
//surf1.set_length(nvnew,nunew);cout<<surf1<<endl;//////////
const double* tvnew=knot_data_v()+j0;
int nvnew2;
double x;
int i,j;
for(i=0; i<nunew; i++){
bluprt_(kv,nvnew,tvnew,surf1.data(0,i,0),
irc,ncd,v0,v1,nmax,work,&nvnew2,tpointer,temppointer,1);
//temp.set_length(nvnew2);cout<<temp<<endl;///////////
for(j=0; j<nvnew2; j++){
x=0.;
for(int k=0; k<ncd; k++)
x-=temp(j,k)*N[k];
if(x<0.) x=-x;
if(x>tol) break;
}
if(j<nvnew2) break;
}
int retcode=1;
if(i<nunew || j<nvnew2){
if(divideU){
// *divideU=direction;
MGVector dfdu=eval(um,vm,1,0), dfdv=eval(um,vm,0,1);
double ulen=dfdu.len()*(u1-u0), vlen=dfdv.len()*(v1-v0);
if(ulen*5.<vlen) *divideU=0;
else if(ulen>vlen*5.) *divideU=1;
else{
//Compute maximum deviation from the plane along u direction.
double udevi0, udevi1, vdevi0, vdevi1;
size_t jm=nvnew2/2;
x=0.;
for(int k=0; k<ncd; k++)
x-=surf1(jm,0,k)*N[k];
udevi0=udevi1=x;
for(i=1; i<nunew; i++){
x=0.;
for(int k=0; k<ncd; k++)
x-=surf1(jm,i,k)*N[k];
if(x<udevi0)
udevi0=x;
if(x>udevi1)
udevi1=x;
}
size_t im=nunew/2;
bluprt_(kv,nvnew,tvnew,surf1.data(0,im,0),
irc,ncd,v0,v1,nmax,work,&nvnew2,tpointer,temppointer,1);
x=0.;
for(int k=0; k<ncd; k++)
x-=temp(0,k)*N[k];
vdevi0=vdevi1=x;
for(j=1; j<nvnew2; j++){
x=0.;
for(int k=0; k<ncd; k++)
x-=temp(j,k)*N[k];
if(x<vdevi0)
vdevi0=x;
if(x>vdevi1)
vdevi1=x;
}
if((udevi1-udevi0)>=(vdevi1-vdevi0))
*divideU=1;
else
*divideU=0;
}
}
retcode=0;
}
delete[] work;
return retcode;
}
void
beziersurface::preprocess ( std::size_t subdiv_u,
std::size_t subdiv_v )
{
// clear old convex hull
_chull.clear();
// elevate if necessary
if (_degree_u < 2) {
elevate_u();
}
if (_degree_v < 2) {
elevate_v();
}
// compute parameter domain partition if necessary
//_trimdomain.partition();
// generate convex hull according to subdivision parameter
pointmesh2d<point_type> cp_orig(_points.begin(), _points.end(), order_u(), order_v());
pointmesh2d<point_type> cp_u;
pointmesh2d<point_type> cp_uv;
trimdomain::bbox_type domainsize = _bezierdomain;
double umin = _bezierdomain.min[point_type::u];
double umax = _bezierdomain.max[point_type::u];
double vmin = _bezierdomain.min[point_type::v];
double vmax = _bezierdomain.max[point_type::v];
value_type range_u = umax - umin;
value_type range_v = vmax - vmin;
value_type step_u = range_u / value_type(subdiv_u+1);
value_type step_v = range_v / value_type(subdiv_v+1);
// for each row of control polygon
for (std::size_t r = 0; r <= _degree_v; ++r)
{
// create knot vector
std::vector<value_type> hlp1(_degree_u+1, umin);
std::vector<value_type> hlp2(_degree_u+1, umax);
std::multiset<value_type> kv_u(hlp1.begin(), hlp1.end());
kv_u.insert(hlp2.begin(), hlp2.end());
std::vector<point_type> row = cp_orig.row(r);
for (std::size_t i = 1; i <= subdiv_u; ++i)
{
converter3d conv;
conv.knot_insertion(row, kv_u, _degree_u + 1, value_type(umin) + value_type(i) * value_type(step_u));
}
cp_u.add_row(row.begin(), row.end());
}
cp_u.transpose();
// for each row of transposed control polygon
for (std::size_t r = 0; r < cp_u.height(); ++r)
{
// create knot vector
std::vector<value_type> hlp1(_degree_v+1, vmin);
std::vector<value_type> hlp2(_degree_v+1, vmax);
std::multiset<value_type> kv_v(hlp1.begin(), hlp1.end());
kv_v.insert(hlp2.begin(), hlp2.end());
std::vector<point_type> row = cp_u.row(r);
for (std::size_t i = 1; i <= subdiv_v; ++i)
{
converter3d conv;
conv.knot_insertion(row, kv_v, _degree_v + 1, value_type(vmin) + value_type(i) * value_type(step_v));
}
cp_uv.add_row(row.begin(), row.end());
}
cp_uv.transpose();
std::vector<gpucast::math::vec4f> uv(cp_uv.width() * cp_uv.height());
// std::generate(uv.begin(), uv.end(), gen_uv(cp_uv.width(), cp_uv.height(),
// min_u_, max_u_, min_v_, max_v_));
// for bezier patches always 0.0 - 1.0 -> min_u, max_u, min_v, max_v are only for trimming ...
// ... as they transform the parameter space into the original b-spline space
std::generate(uv.begin(), uv.end(), uvgenerator<gpucast::math::vec4f> ( cp_uv.width(),
cp_uv.height(),
float(0),
float(1),
float(0),
float(1),
bit_cast<unsigned, float>(unsigned(order_u())),
bit_cast<unsigned, float>(unsigned(order_v()))));
std::vector<gpucast::math::vec4f> attrib(uv.size());
pointmesh2d<gpucast::math::vec4f> cp_color (uv.begin(), uv.end(), cp_uv.width(), cp_uv.height());
pointmesh2d<gpucast::math::vec4f> cp_attrib(uv.begin(), uv.end(), cp_uv.width(), cp_uv.height());
// generate chulls for each subdivision and merge them
for (std::size_t v = 0; v <= subdiv_v; ++v)
{
for (std::size_t u = 0; u <= subdiv_u; ++u)
{
// copy control points of submesh
pointmesh2d<point3d> subpat = cp_uv.subpatch (u * _degree_u, (u+1)*_degree_u, v * _degree_v, (v+1)*_degree_v);
// copy 4-double texture coordinate information from submesh
pointmesh2d<gpucast::math::vec4f> subpat_col = cp_color.subpatch (u * _degree_u, (u+1)*_degree_u, v * _degree_v, (v+1)*_degree_v);
// discard rational component of control points for convex hull generation
std::vector<gpucast::math::vec3d> tmp;
std::transform(subpat.begin(), subpat.end(), std::inserter(tmp, tmp.end()), gpucast::math::rational_to_euclid3d<point3d>());
// generate chull for subpatch
convex_hull tmp_ch;
tmp_ch.set(tmp.begin(), tmp.end(), subpat_col.begin(), subpat_col.end());
// merge chull with complete chull
_chull.merge(tmp_ch);
}
}
}
