src/TopOpeBRepTool/TopOpeBRepTool_makeTransition.cxx

   1 // Created on: 1999-02-11
   2 // Created by: Xuan PHAM PHU
   3 // Copyright (c) 1999-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and / or modify it
   9 // under the terms of the GNU Lesser General Public version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #include <TopOpeBRepTool_TOOL.hxx>
  18 #include <TopOpeBRepTool_EXPORT.hxx>
  19 #include <TopOpeBRepTool_makeTransition.ixx>
  20 #include <TopOpeBRepTool_define.hxx>
  21 #include <BRep_Tool.hxx>
  22 #include <Precision.hxx>
  23 #include <BRepAdaptor_Curve.hxx>
  24 #include <BRepAdaptor_Surface.hxx>
  25
  26 #define BEFORE (1)
  27 #define AFTER  (2)
  28
  29 #define isINifh1   (1)
  30 #define isINifh2   (2)
  31 #define isON2     (21)
  32 #define isON2ifss (10)
  33 #define isIN2ifss (11)
  34 #define isOU2ifss (12)
  35
  36 #define INFFIRST (-1)
  37 #define SUPLAST (-2)
  38 #define ONFIRST (1)
  39 #define ONLAST  (2)
  40
  41 #define FORWARD  (1)
  42 #define REVERSED (2)
  43 #define INTERNAL (3)
  44 #define EXTERNAL (4)
  45 #define CLOSING  (5)
  46
  47 #define M_ON(sta)       (sta == TopAbs_ON)
  48 #define M_IN(sta)       (sta == TopAbs_IN)
  49 #define M_FORWARD(sta)  (sta == TopAbs_FORWARD)
  50 #define M_REVERSED(sta) (sta == TopAbs_REVERSED)
  51 #define M_INTERNAL(sta) (sta == TopAbs_INTERNAL)
  52 #define M_EXTERNAL(sta) (sta == TopAbs_EXTERNAL)
  53 #define M_UNKNOWN(sta)  (sta == TopAbs_UNKNOWN)
  54
  55 static Standard_Real FUN_tolang()
  56 {
  57   return Precision::Angular()*1.e6;//=1.e-6 NYITOLXPU
  58 }
  59
  60 //=======================================================================
  61 //function : TopOpeBRepTool_makeTransition
  62 //purpose  :
  63 //=======================================================================
  64
  65 TopOpeBRepTool_makeTransition::TopOpeBRepTool_makeTransition()
  66 {
  67 }
  68
  69 //=======================================================================
  70 //function : Initialize
  71 //purpose  :
  72 //=======================================================================
  73
  74 Standard_Boolean TopOpeBRepTool_makeTransition::Initialize
  75 (const TopoDS_Edge& E,const Standard_Real pbef,const Standard_Real paft,const Standard_Real parE,
  76  const TopoDS_Face& FS, const gp_Pnt2d& uv,
  77  const Standard_Real factor)
  78 {
  79   Standard_Boolean isdge = BRep_Tool::Degenerated(E);
  80   if (isdge) return Standard_False;
  81
  82   myE = E;
  83   mypb = pbef; mypa = paft; mypE = parE;
  84   myFS = FS; myuv = uv;
  85   myfactor = factor;
  86   hasES = Standard_False;
  87
  88   Standard_Boolean facko = (factor < 0.) || (factor > 1.);
  89   if (facko) return Standard_False;
  90
  91   Standard_Boolean ok = TopOpeBRepTool_TOOL::EdgeONFace(mypE,myE,myuv,FS,isT2d);
  92   return ok;
  93 }
  94
  95 //=======================================================================
  96 //function : Setfactor
  97 //purpose  :
  98 //=======================================================================
  99
 100 void TopOpeBRepTool_makeTransition::Setfactor(const Standard_Real factor)
 101 {
 102   myfactor = factor;
 103 }
 104
 105 //=======================================================================
 106 //function : Getfactor
 107 //purpose  :
 108 //=======================================================================
 109
 110 Standard_Real TopOpeBRepTool_makeTransition::Getfactor() const
 111 {
 112   return myfactor;
 113 }
 114
 115 //=======================================================================
 116 //function : IsT2d
 117 //purpose  :
 118 //=======================================================================
 119
 120 Standard_Boolean TopOpeBRepTool_makeTransition::IsT2d() const
 121 {
 122   return isT2d;
 123 }
 124
 125
 126
 127 //=======================================================================
 128 //function : SetRest
 129 //purpose  :
 130 //=======================================================================
 131
 132 Standard_Boolean TopOpeBRepTool_makeTransition::SetRest(const TopoDS_Edge& ES, const Standard_Real parES)
 133 {
 134   Standard_Boolean isdge = BRep_Tool::Degenerated(ES);
 135   if (isdge) return Standard_False;
 136
 137   hasES = Standard_True;
 138   myES = ES;
 139   mypES = parES;
 140
 141   // nyi check <ES> is edge of <myFS>
 142   return Standard_True;
 143 }
 144
 145 //=======================================================================
 146 //function : HasRest
 147 //purpose  :
 148 //=======================================================================
 149
 150 Standard_Boolean TopOpeBRepTool_makeTransition::HasRest() const
 151 {
 152   return hasES;
 153 }
 154
 155 static Standard_Boolean FUN_nullcurv(const Standard_Real curv)
 156 {
 157   Standard_Real tol = Precision::Confusion()*1.e+2;//NYITOLXPU
 158   return (curv < tol);
 159 }
 160
 161 static Standard_Integer FUN_mkT2dquad(const Standard_Real curvC1, const Standard_Real curvC2)
 162 {
 163   // !!! only for quadratic geometries :
 164   // prequesitory : C1 and C2 are ON given plane; they are tangent
 165   // at point pt, where curvatures are respectively curvC1,curvC2
 166   // stb = state of point on C1 before pt / C2
 167   // = sta = state of point on C1 after pt / C2
 168
 169   Standard_Boolean nullc1  = FUN_nullcurv(curvC1);
 170   Standard_Boolean nullc2 = FUN_nullcurv(curvC2);
 171   if (nullc2 && nullc1) return isON2;
 172   if (nullc2) return isINifh1;//is IN if (dot=tg1(pt after).xx2 > 0)
 173   if (nullc1) return isINifh2;//is IN if (dot=tg2(pt after).xx2 < 0)
 174
 175   Standard_Boolean samec = (Abs(curvC2-curvC1) < 1.e-2); //NYITOLXPU kpartkoletge
 176   if (samec)           return isON2ifss;//is ON if curves are on same side/tg line
 177   if (curvC1 > curvC2) return isIN2ifss;//is IN if curves are on same side/tg line
 178   else                 return isOU2ifss;//is OU if curves are on same side/tg line
 179 //  return 0;
 180 }
 181
 182 static Standard_Boolean FUN_getnearpar(const TopoDS_Edge& e,const Standard_Real par,const Standard_Real f,const Standard_Real l,
 183                           const Standard_Real factor,const Standard_Integer sta, Standard_Real& nearpar)
 184 {
 185   // hyp : f < par < l
 186   BRepAdaptor_Curve bc(e);
 187   Standard_Real tol1d = bc.Resolution( bc.Tolerance() );
 188   Standard_Boolean onf = (Abs(par-f) < tol1d);
 189   Standard_Boolean onl = (Abs(par-l) < tol1d);
 190   if (onf && (sta == BEFORE)) return Standard_False;
 191   if (onl && (sta == AFTER))  return Standard_False;
 192   //nearpar = (sta == BEFORE) ? ((1-factor)*par - factor*f) : ((1-factor)*par - factor*l);
 193   nearpar = (sta == BEFORE) ? (par - factor*(l-f)) : (par + factor*(l-f));
 194   return Standard_True;
 195 }
 196
 197 static Standard_Boolean FUN_tg(const TopoDS_Edge& e,const Standard_Real par,const Standard_Real f,const Standard_Real l,const Standard_Real factor,
 198                   gp_Dir& tg, Standard_Integer& st)
 199 {
 200   st = BEFORE;
 201   for (Standard_Integer nite = 1; nite <= 2; nite++) {
 202     if (nite == 2) st = AFTER;
 203     Standard_Real pn; Standard_Boolean mkp = FUN_getnearpar(e,par,f,l,factor,st,pn);
 204     if (!mkp) continue;
 205     gp_Vec tmp; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(pn,e,tmp);
 206     if (!ok) continue;
 207     tg = gp_Dir(tmp);
 208     return Standard_True;
 209   }
 210   return Standard_False;
 211 }
 212 static Standard_Boolean FUN_getsta(const Standard_Integer mkt,const gp_Dir& tga1,const gp_Dir& tga2,const gp_Dir& xx2,
 213                       TopAbs_State& sta)
 214 {
 215   if      (mkt == isINifh1) {
 216     // curv(e1) > 0.
 217     //is IN if (dot=tg1(pt after).xx2 > 0)
 218     Standard_Real dot = tga1.Dot(xx2);
 219     sta =  (dot > 0) ? TopAbs_IN : TopAbs_OUT;
 220     return Standard_True;
 221   }
 222   else if (mkt == isINifh2) {
 223     // curv(e2) > 0.
 224     //is IN if (dot=tg2(pt after).xx2 < 0)
 225     Standard_Real dot = tga2.Dot(xx2);
 226     sta =  (dot < 0) ? TopAbs_IN : TopAbs_OUT;
 227     return Standard_True;
 228   }
 229   else if (mkt == isON2ifss) {
 230     // curv(e1), curv(e2) > 0.
 231     //is ON if curves are on same side/tg line
 232     Standard_Boolean ssided = (tga1.Dot(tga2) > 0);
 233     sta = ssided ? TopAbs_ON : TopAbs_IN;
 234     return Standard_True;
 235   }
 236   else if (mkt == isIN2ifss) {
 237     //stag = IN if curves are on same side/tg line
 238     Standard_Real dot = tga1.Dot(xx2);
 239     sta = (dot < 0) ? TopAbs_OUT : TopAbs_IN;
 240     return Standard_True;
 241   }
 242   else if (mkt == isOU2ifss) {
 243     //stag = OU if curves are on same side/tg line
 244     Standard_Real dot = tga2.Dot(xx2);
 245     sta = (dot < 0) ? TopAbs_IN : TopAbs_OUT;
 246     return Standard_True;
 247   }
 248   else {//mkt == isON2
 249     sta = TopAbs_ON;
 250     return Standard_True;
 251   }
 252 }
 253 static Standard_Boolean FUN_mkT2dquad(const TopoDS_Edge& e1,const Standard_Real par1,const Standard_Real f1,const Standard_Real l1,
 254                          const TopoDS_Edge& e2,const Standard_Real par2,
 255                          const Standard_Integer mkt,const gp_Dir& xx2,const Standard_Real factor,
 256                          TopAbs_State& sta)
 257 {
 258   sta = TopAbs_UNKNOWN;
 259
 260   // !!! only for quadratic geometries :
 261   // stb = state of point on e1 before pt / e2
 262   // = sta = state of point on e1 after pt / e2
 263
 264   gp_Dir tga1,tga2;
 265   Standard_Boolean mk1 = isINifh1 || isON2ifss || isIN2ifss;
 266   if (mk1) {
 267     Standard_Integer st1 = 0; gp_Dir tgnear1;
 268     Standard_Boolean ok = FUN_tg(e1,par1,f1,l1,factor,tgnear1,st1);
 269     if (!ok) return Standard_False;
 270     tga1 = (st1 == AFTER) ? tgnear1 : tgnear1.Reversed();
 271   }
 272   Standard_Boolean mk2 = isINifh2 || isON2ifss || isOU2ifss;
 273   if (mk2) {
 274     Standard_Real f2,l2; FUN_tool_bounds(e2,f2,l2);
 275     Standard_Integer st2 = 0; gp_Dir tgnear2;
 276     Standard_Boolean ok = FUN_tg(e2,par2,f2,l2,factor,tgnear2,st2);
 277     if (!ok) return Standard_False;
 278     tga2 = (st2 == AFTER) ? tgnear2 : tgnear2.Reversed();
 279   }
 280   return (FUN_getsta(mkt,tga1,tga2,xx2, sta));
 281 }
 282
 283 //=======================================================================
 284 //function : MkT2donE
 285 //purpose  :
 286 //=======================================================================
 287
 288 Standard_Boolean TopOpeBRepTool_makeTransition::MkT2donE(TopAbs_State& Stb,TopAbs_State& Sta) const
 289 {
 290   if (!isT2d) return Standard_False;
 291
 292   // E is IN 2d(FS), meets no restriction at given point :
 293   if (!hasES) {Stb = Sta = TopAbs_IN; return Standard_True;}
 294
 295   // E is IN 2d(FS), meets restriction ES at given point :
 296   Standard_Integer oriESFS = TopOpeBRepTool_TOOL::OriinSor(myES,myFS, Standard_True);
 297   if (oriESFS == 0) return Standard_False;
 298
 299   // ES is closing edge for FS, or ES is INTERNAL in FS :
 300   if      (oriESFS == INTERNAL) {Stb = Sta = TopAbs_IN; return Standard_True;}
 301   else if (oriESFS == CLOSING)  {Stb = Sta = TopAbs_IN; return Standard_True;}
 302
 303   gp_Vec tmp; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(mypE,myE,tmp);
 304   if (!ok) return Standard_False;
 305   gp_Dir tgE(tmp);
 306   gp_Dir xxES; ok = TopOpeBRepTool_TOOL::XX(myuv,myFS, mypES,myES, xxES);
 307   if (!ok) return Standard_False;
 308
 309   Standard_Real tola = FUN_tolang();
 310   Standard_Real dot = tgE.Dot(xxES);
 311
 312   // E and ES are not tangent at interference point :
 313   Standard_Boolean tgts = (Abs(dot) < tola);
 314   if (!tgts) {
 315     Standard_Boolean dotpos = (dot > 0.);
 316     if (dotpos) {Stb = TopAbs_OUT; Sta = TopAbs_IN;}
 317     else        {Stb = TopAbs_IN; Sta = TopAbs_OUT;}
 318     return Standard_True;
 319   }
 320
 321   // E and ES are tangent, curves are quadratic :transition is INTERNAL/EXTERNAL,
 322   // elsewhere                                  : transition is FOR/REV/INT/EXT
 323   // we then use curvatures to compute transition T :
 324   // xpu090299 PRO13455(E=e7, ES=e9, FS=f11)
 325   gp_Dir ntFS; ok = TopOpeBRepTool_TOOL::Nt(myuv,myFS,ntFS);
 326   if (!ok) return Standard_False;
 327   Standard_Real curvE;  ok = TopOpeBRepTool_TOOL::CurvE(myE,mypE,ntFS,curvE);
 328   if (!ok) return Standard_False;
 329   Standard_Real curvES; ok = TopOpeBRepTool_TOOL::CurvE(myES,mypES,ntFS,curvES);
 330   if (!ok) return Standard_False;
 331
 332   Standard_Boolean quadE  = TopOpeBRepTool_TOOL::IsQuad(myE);
 333   Standard_Boolean quadES = TopOpeBRepTool_TOOL::IsQuad(myES);
 334   if (quadE && quadES) { // should return INT/EXT
 335     TopAbs_State sta = TopAbs_UNKNOWN;
 336     Standard_Integer mkt = FUN_mkT2dquad(curvE,curvES);
 337     Standard_Boolean ok  = FUN_mkT2dquad(myE,mypb,mypa,mypE, myES,mypES, mkt,xxES,myfactor,sta);
 338     if (ok) {
 339       Stb = Sta = sta;
 340       return Standard_True;
 341     }
 342   }
 343
 344   // !!!NYI: general case :
 345   // ----------------------
 346   // NYIKPART quadquad, only one state
 347   return Standard_False;
 348 }
 349
 350 static Standard_Boolean FUN_getnearuv(const TopoDS_Face& f,const gp_Pnt2d& uv,
 351                          const Standard_Real factor,const Standard_Integer sta,const gp_Dir2d& duv,
 352                          gp_Pnt2d& nearuv)
 353 {
 354   BRepAdaptor_Surface bs(f);
 355
 356   gp_Vec2d xuv = gp_Vec2d(duv).Multiplied(factor);
 357   if (sta == BEFORE) xuv.Reverse();
 358   nearuv = uv.Translated(xuv) ;
 359
 360   Standard_Integer onu,onv; TopOpeBRepTool_TOOL::stuvF(uv,f, onu,onv);
 361   Standard_Boolean uok = (onu == 0);
 362   Standard_Boolean vok = (onv == 0);
 363   if (uok && vok) return Standard_True;
 364
 365   Standard_Real nearu = nearuv.X(), nearv = nearuv.Y();
 366
 367   if ((onu == INFFIRST)||(onu == SUPLAST)) {
 368     Standard_Boolean ucl = bs.IsUClosed();
 369     if (!ucl) return Standard_False;
 370     Standard_Real uper = bs.UPeriod();
 371     if (onu == INFFIRST) nearu += uper;
 372     else                 nearu -= uper;
 373   }
 374
 375   if ((onv == INFFIRST)||(onv == SUPLAST)) {
 376     Standard_Boolean vcl = bs.IsVClosed();
 377     if (!vcl) return Standard_False;
 378     Standard_Real vper = bs.VPeriod();
 379     if (onv == INFFIRST) nearv += vper;
 380     else                 nearv -= vper;
 381   }
 382   nearuv = gp_Pnt2d(nearu,nearv);
 383   return Standard_True;
 384 }//FUN_getnearuv
 385 static Standard_Boolean FUN_tgef(const TopoDS_Face& f,
 386                                  const gp_Pnt2d& uv,
 387                                  const gp_Dir2d& duv,
 388                                  const Standard_Real factor,
 389 //                               const gp_Dir& tge,
 390                                  const gp_Dir& ,
 391                                  const gp_Dir& tg0,
 392                                  gp_Dir& tgef,
 393                                  Standard_Integer& st)
 394 {
 395   st = BEFORE;
 396   for (Standard_Integer nite = 1; nite <= 2; nite++) {
 397     if (nite == 2) st = AFTER;
 398     gp_Pnt2d nearuv;
 399 //    Standard_Real pn;
 400     Standard_Boolean mkp = FUN_getnearuv(f,uv,factor,st,duv, nearuv);
 401     if (!mkp) continue;
 402     gp_Dir nt; Standard_Boolean ok = TopOpeBRepTool_TOOL::Nt(nearuv,f,nt);
 403     if (!ok) return Standard_False;
 404     // recall : ntf^tge = tg0, (tgef(uv) = tge)
 405     //          => near interference point, we assume nt^tgef(nearuv) = tg0
 406     tgef = tg0.Crossed(nt);
 407     return Standard_True;
 408   }
 409   return Standard_False;
 410 }//FUN_tgef
 411 static Standard_Boolean FUN_mkT3dquad(const TopoDS_Edge& e,const Standard_Real pf,const Standard_Real pl,const Standard_Real par,
 412                          const TopoDS_Face& f,const gp_Pnt2d& uv,
 413                          const gp_Dir& tge,const gp_Dir& ntf,
 414                          const Standard_Integer mkt,const Standard_Real factor, TopAbs_State& sta)
 415
 416 {
 417   // stb = state of point on e before pt / ef
 418   // = sta = state of point on e after pt / ef
 419   sta = TopAbs_UNKNOWN;
 420   gp_Dir xxef = ntf.Reversed();
 421   gp_Dir tg0 = ntf.Crossed(tge);
 422
 423   gp_Dir tgae,tgaef;
 424   Standard_Boolean mke = (mkt==isINifh1) || (mkt==isON2ifss) || (mkt==isIN2ifss);
 425   if (mke) {
 426     Standard_Integer st = 0; gp_Dir tgnear; Standard_Boolean ok = FUN_tg(e,par,pf,pl,factor,tgnear,st);
 427     if (!ok) return Standard_False;
 428     tgae = (st == AFTER) ? tgnear : tgnear.Reversed();
 429   }
 430   Standard_Boolean mkef = (mkt==isINifh2) || (mkt==isON2ifss) || (mkt==isOU2ifss);
 431   if (mkef) {
 432     // choice : tgdir(ef,uv) = tgdir(e,pare)
 433     Standard_Real fac3d = 0.01; //0.12345; not only planar faces
 434     gp_Dir2d duv; Standard_Boolean ok = TopOpeBRepTool_TOOL::Getduv(f,uv,tge,fac3d, duv);
 435     if (!ok) return Standard_False;
 436     gp_Dir tgnear; Standard_Integer st = 0; ok = FUN_tgef(f,uv,duv,factor, tge,tg0, tgnear,st);
 437     if (!ok) return Standard_False;
 438     tgaef = (st == AFTER) ? tgnear : tgnear.Reversed();
 439   }
 440   return (FUN_getsta(mkt,tgae,tgaef,xxef, sta));
 441 }
 442
 443 static TopAbs_State FUN_stawithES(const gp_Dir& tgE,const gp_Dir& xxES,const Standard_Integer st)
 444 {
 445   // prequesitory : FS and E are tangent at interference point
 446   // ---------------------------------------------------------
 447   // xxES : normal to ES oriented INSIDE 2d(FS)
 448   // tgE  : tangent to E at Pt
 449   // pt(st,E) (st=BEFORE,AFTER) has been found IN 3dFS()
 450
 451   TopAbs_State sta;
 452   Standard_Real prod = tgE.Dot(xxES);
 453   Standard_Real tola = FUN_tolang();
 454   if (Abs(prod) < tola) return TopAbs_UNKNOWN;
 455   Standard_Boolean positive = (prod > 0.);
 456   if (positive) sta = (st == BEFORE) ? TopAbs_OUT : TopAbs_IN; //T.Set(TopAbs_FORWARD);
 457   else          sta = (st == BEFORE) ? TopAbs_IN : TopAbs_OUT;//T.Set(TopAbs_REVERSED);
 458 //  sta = (iP == BEFORE) ? T.Before() : T.After();
 459   return sta;
 460 }//FUN_stawithES
 461 static TopAbs_State FUN_stawithES(const gp_Dir& tgE,const gp_Dir& xxES,const Standard_Integer st,const TopAbs_State stt)
 462 {
 463   TopAbs_State str = TopAbs_UNKNOWN;
 464   if (M_UNKNOWN(stt)) return str;
 465
 466   TopAbs_State stES = FUN_stawithES(tgE,xxES,st);
 467   // we keep statx as IN or ON if xwithline is IN
 468   if (M_IN(stt) || M_ON(stt)) str = M_IN(stES) ? stt : TopAbs_OUT;
 469   return str;
 470 }
 471
 472 static Standard_Boolean FUN_staproj(const TopoDS_Edge& e,const Standard_Real pf,const Standard_Real pl,const Standard_Real pe,
 473                        const Standard_Real factor, const Standard_Integer st, const TopoDS_Face& f,
 474                        TopAbs_State& sta)
 475 {
 476   Standard_Real par;Standard_Boolean ok = FUN_getnearpar(e,pe,pf,pl,factor,st, par);
 477   if (!ok) return Standard_False;
 478   gp_Pnt pt;  ok = FUN_tool_value(par,e, pt);
 479   if (!ok) return Standard_False;
 480   gp_Pnt2d uv; ok = TopOpeBRepTool_TOOL::Getstp3dF(pt,f,uv,sta);
 481   return ok;
 482 }
 483
 484 //=======================================================================
 485 //function : MkT3dproj
 486 //purpose  : can return in,out,on
 487 //=======================================================================
 488
 489 Standard_Boolean TopOpeBRepTool_makeTransition::MkT3dproj(TopAbs_State& Stb,TopAbs_State& Sta) const
 490 {
 491   Stb = Sta = TopAbs_UNKNOWN;
 492   Standard_Boolean okb = FUN_staproj(myE,mypb,mypa,mypE, myfactor,BEFORE,myFS, Stb);
 493   if (!okb) return Standard_False;
 494   Standard_Boolean oka = FUN_staproj(myE,mypb,mypa,mypE, myfactor,AFTER,myFS, Sta);
 495   if (!oka) return Standard_False;
 496   return Standard_True;
 497 }
 498
 499 //=======================================================================
 500 //function : MkT3donE
 501 //purpose  :
 502 //   <myE> is tangent to <myFS> at point P = Pt(<myuv>,<myFS>) = Pt(<mypE>,<myE>)
 503 //   <tgE> = E's tangent at P,
 504 //   <ntF> = <F>'s topological normal at P.
 505
 506 //   These define a plane Pln = (O = P, XY = (<ntF>,<tgE>)),
 507 //   the projection of <F> in Pln describes an bounding edge eF in 2dspace(Pln)
 508
 509 //   In thePlane :
 510 //   P -> myuv
 511 //   <ntF> -> 2d axis x
 512 //   <tgE> -> 2d axis y
 513 // ================================================================================
 514
 515 Standard_Boolean TopOpeBRepTool_makeTransition::MkT3onE(TopAbs_State& Stb,TopAbs_State& Sta) const
 516 {
 517   if (isT2d) return Standard_False;
 518   gp_Vec tmp; Standard_Boolean ok = TopOpeBRepTool_TOOL::TggeomE(mypE,myE,tmp);
 519   if (!ok) return Standard_False;
 520   gp_Dir tgE(tmp);
 521   gp_Dir ntFS; ok = TopOpeBRepTool_TOOL::Nt(myuv,myFS,ntFS);
 522   if (!ok) return Standard_False;
 523
 524   Standard_Real tola = FUN_tolang();
 525   Standard_Real dot = tgE.Dot(ntFS);
 526
 527   if (Abs(dot) > tola) {
 528     Stb = (dot > 0) ? TopAbs_IN : TopAbs_OUT;
 529     Sta = (dot > 0) ? TopAbs_OUT : TopAbs_IN;
 530 //    TopAbs_Orientation oE = (dot > 0) ? TopAbs_REVERSED : TopAbs_FORWARD;
 531 //    T.Set(oE);
 532     return Standard_True;
 533   }
 534
 535   //E is tangent to FS at interference point
 536   gp_Dir tg0 = ntFS.Crossed(tgE);
 537   Standard_Real curE; ok = TopOpeBRepTool_TOOL::CurvE(myE,mypE,tg0, curE);
 538   if (!ok) return Standard_False;
 539   Standard_Real curFS; Standard_Boolean direct; ok = TopOpeBRepTool_TOOL::CurvF(myFS,myuv,tg0, curFS,direct);
 540   if (!ok) return Standard_False;
 541
 542   Standard_Boolean quadE   = TopOpeBRepTool_TOOL::IsQuad(myE);
 543   Standard_Boolean quadFS  = TopOpeBRepTool_TOOL::IsQuad(myFS);
 544   if (quadE && quadFS) { // should return INT/EXT
 545     Standard_Integer mkt = FUN_mkT2dquad(curE,curFS);
 546     TopAbs_State sta = TopAbs_UNKNOWN;
 547     ok = FUN_mkT3dquad(myE,mypb,mypa,mypE, myFS,myuv, tgE,ntFS, mkt,myfactor,sta);
 548     if (ok) {
 549       if (hasES) {
 550         gp_Dir xxES; Standard_Boolean ok = TopOpeBRepTool_TOOL::XX(myuv,myFS, mypES,myES, xxES);
 551         if (!ok) return Standard_False;
 552         Stb = FUN_stawithES(tgE,xxES,BEFORE,sta);
 553         Sta = FUN_stawithES(tgE,xxES,AFTER,sta);
 554       }
 555       else {
 556         Stb = Sta = sta;
 557       }
 558       return Standard_True;
 559     }
 560   }
 561
 562   // NYIGENERALCASE;
 563   // NYIKPART quadquad, only one state
 564   return Standard_False;
 565 }
 566
 567 //=======================================================================
 568 //function : MkTonE
 569 //purpose  :
 570 //=======================================================================
 571
 572 Standard_Boolean TopOpeBRepTool_makeTransition::MkTonE(TopAbs_State& Stb,TopAbs_State& Sta)
 573 {
 574   Stb = Sta = TopAbs_UNKNOWN;
 575   if (isT2d) return (MkT2donE(Stb,Sta));
 576
 577   Standard_Boolean ok = MkT3onE(Stb,Sta);
 578   if (!ok) ok = MkT3dproj(Stb, Sta);
 579 //  if (!ok) return Standard_False;
 580
 581   gp_Vec tmp; ok = TopOpeBRepTool_TOOL::TggeomE(mypE,myE,tmp);
 582   if (!ok) return Standard_False;
 583   gp_Dir tgE(tmp);
 584   gp_Dir xxES;
 585   if (hasES && ok) {ok = TopOpeBRepTool_TOOL::XX(myuv,myFS, mypES,myES, xxES);
 586                     if (!ok) return Standard_False;}
 587
 588   Standard_Real delta = (1. - myfactor)/5.;
 589   Standard_Boolean kob=Standard_False, koa=Standard_False;
 590   for (Standard_Integer nite = 1; nite <= 5; nite++) {
 591     kob = (Stb == TopAbs_ON)||(Stb == TopAbs_UNKNOWN);
 592     koa = (Sta == TopAbs_ON)||(Sta == TopAbs_UNKNOWN);
 593     if (!koa && !kob) return Standard_True;
 594
 595     Standard_Boolean okb=Standard_True, oka=Standard_True;
 596     if (kob) {
 597       okb = FUN_staproj(myE,mypb,mypa,mypE, myfactor,BEFORE,myFS, Stb);
 598       if (okb && hasES) {TopAbs_State stb = Stb; Stb = FUN_stawithES(tgE,xxES,BEFORE,stb);}
 599     }
 600     if (koa) {
 601       oka = FUN_staproj(myE,mypb,mypa,mypE, myfactor,AFTER,myFS, Sta);
 602       if (oka && hasES) {TopAbs_State sta = Sta; Sta = FUN_stawithES(tgE,xxES,AFTER,sta);}
 603     }
 604
 605     myfactor += delta;
 606   }//nite=1..5
 607   return Standard_False;
 608 }
 609