src/HLRBRep/HLRBRep_EdgeBuilder.cxx

   1 // Created on: 1997-04-17
   2 // Created by: Christophe MARION
   3 // Copyright (c) 1997-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 under
   9 // the terms of the GNU Lesser General Public License 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 #ifndef No_Exception
  18 #define No_Exception
  19 #endif
  20
  21
  22 #include <HLRAlgo_Intersection.hxx>
  23 #include <HLRBRep_AreaLimit.hxx>
  24 #include <HLRBRep_EdgeBuilder.hxx>
  25 #include <HLRBRep_VertexList.hxx>
  26 #include <Standard_DomainError.hxx>
  27 #include <Standard_NoMoreObject.hxx>
  28 #include <Standard_NoSuchObject.hxx>
  29 #include <TopAbs.hxx>
  30
  31 //=======================================================================
  32 //function : HLRBRep_EdgeBuilder
  33 //purpose  :
  34 //=======================================================================
  35 HLRBRep_EdgeBuilder::HLRBRep_EdgeBuilder (HLRBRep_VertexList& VList)
  36 {
  37   // at creation the EdgeBuilder explore the VertexList
  38   // and use it to build a list of "AreaLimit" on the edge.
  39   // An area is a part of the curve between
  40   // two consecutive vertices
  41
  42   Standard_DomainError_Raise_if(!VList.More(),
  43                                 "EdgeBuilder  : Empty vertex list");
  44
  45   Handle(HLRBRep_AreaLimit) last,cur;
  46   TopAbs_State before,after,ebefore,eafter;
  47   HLRAlgo_Intersection V;
  48
  49   // loop on the Vertices
  50   for (;VList.More();VList.Next()) {
  51     before = after = ebefore = eafter = TopAbs_UNKNOWN;
  52     // compute the states
  53     if (VList.IsBoundary()) {
  54       switch (VList.Orientation()) {
  55
  56       case TopAbs_FORWARD :
  57         ebefore = TopAbs_OUT;
  58         eafter  = TopAbs_IN;
  59         break;
  60
  61       case TopAbs_REVERSED :
  62         ebefore = TopAbs_IN;
  63         eafter  = TopAbs_OUT;
  64         break;
  65
  66       case TopAbs_INTERNAL :
  67         ebefore = TopAbs_IN;
  68         eafter  = TopAbs_IN;
  69         break;
  70
  71       case TopAbs_EXTERNAL :
  72         ebefore = TopAbs_OUT;
  73         eafter  = TopAbs_OUT;
  74         break;
  75       }
  76     }
  77
  78     if (VList.IsInterference()) {
  79       switch (VList.Transition()) {
  80
  81       case TopAbs_FORWARD :
  82         before = TopAbs_OUT;
  83         after  = TopAbs_IN;
  84         break;
  85
  86       case TopAbs_REVERSED :
  87         before = TopAbs_IN;
  88         after  = TopAbs_OUT;
  89         break;
  90
  91       case TopAbs_INTERNAL :
  92         before = TopAbs_IN;
  93         after  = TopAbs_IN;
  94         break;
  95
  96       case TopAbs_EXTERNAL :
  97         before = TopAbs_OUT;
  98         after  = TopAbs_OUT;
  99         break;
 100       }
 101
 102       switch (VList.BoundaryTransition()) {
 103
 104       case TopAbs_FORWARD :
 105         after  = TopAbs_ON;
 106         break;
 107
 108       case TopAbs_REVERSED :
 109         before = TopAbs_ON;
 110         break;
 111
 112       case TopAbs_INTERNAL :
 113         before = TopAbs_ON;
 114         after  = TopAbs_ON;
 115         break;
 116
 117       case TopAbs_EXTERNAL :
 118         break;
 119       }
 120     }
 121
 122     // create the Limit and connect to list
 123     V = VList.Current();
 124     cur = new HLRBRep_AreaLimit(V,
 125                                  VList.IsBoundary(),
 126                                  VList.IsInterference(),
 127                                  before,after,
 128                                  ebefore,eafter);
 129     if (myLimits.IsNull()) {
 130       myLimits = cur;
 131       last     = cur;
 132     }
 133     else {
 134       last->Next(cur);
 135       cur->Previous(last);
 136       last = cur;
 137     }
 138   }
 139
 140   // periodicity, make a circular list
 141   if (VList.IsPeriodic()) {
 142     last->Next(myLimits);
 143     myLimits->Previous(last);
 144   }
 145
 146   // process UNKNOWN areas
 147   TopAbs_State  stat = TopAbs_UNKNOWN;
 148   TopAbs_State estat = TopAbs_UNKNOWN;
 149
 150   cur = myLimits;
 151   while (!cur.IsNull()) {
 152     if (stat == TopAbs_UNKNOWN) {
 153       stat = cur->StateBefore();
 154       if (stat == TopAbs_UNKNOWN) {
 155         stat = cur->StateAfter();
 156       }
 157     }
 158     if (estat == TopAbs_UNKNOWN) {
 159       estat = cur->EdgeBefore();
 160       if (estat == TopAbs_UNKNOWN) {
 161         estat = cur->EdgeAfter();
 162       }
 163     }
 164     cur = cur->Next();
 165     // test for periodicicity
 166     if (cur == myLimits)
 167       break;
 168   }
 169
 170   // error if no interferences
 171   Standard_DomainError_Raise_if(stat == TopAbs_UNKNOWN,
 172                                 "EdgeBuilder : No interferences");
 173   // if no boundary the edge covers the whole curve
 174   if (estat == TopAbs_UNKNOWN)
 175     estat = TopAbs_IN;
 176
 177   // propagate states
 178   cur = myLimits;
 179   while (!cur.IsNull()) {
 180     if (cur->StateBefore() == TopAbs_UNKNOWN)
 181       cur->StateBefore(stat);
 182     else
 183       stat = cur->StateAfter();
 184     if (cur->StateAfter() == TopAbs_UNKNOWN)
 185       cur->StateAfter(stat);
 186     if (cur->EdgeBefore() == TopAbs_UNKNOWN)
 187       cur->EdgeBefore(estat);
 188     else
 189       estat = cur->EdgeAfter();
 190     if (cur->EdgeAfter() == TopAbs_UNKNOWN)
 191       cur->EdgeAfter(estat);
 192
 193     cur = cur->Next();
 194     if (cur == myLimits)
 195       break;
 196   }
 197
 198   // initialise with IN parts
 199   Builds(TopAbs_IN);
 200 }
 201
 202 //=======================================================================
 203 //function : InitAreas
 204 //purpose  : set on the first area
 205 //=======================================================================
 206
 207 void HLRBRep_EdgeBuilder::InitAreas()
 208 {
 209   left = myLimits->Previous();
 210   right = myLimits;
 211 }
 212
 213 //=======================================================================
 214 //function : NextArea
 215 //purpose  :
 216 //=======================================================================
 217
 218 void HLRBRep_EdgeBuilder::NextArea()
 219 {
 220   left = right;
 221   if (!right.IsNull())
 222     right = right->Next();
 223 }
 224
 225 //=======================================================================
 226 //function : PreviousArea
 227 //purpose  :
 228 //=======================================================================
 229
 230 void HLRBRep_EdgeBuilder::PreviousArea()
 231 {
 232   right = left;
 233   if (!left.IsNull())
 234     left = left->Previous();
 235 }
 236
 237 //=======================================================================
 238 //function : HasArea
 239 //purpose  :
 240 //=======================================================================
 241
 242 Standard_Boolean HLRBRep_EdgeBuilder::HasArea() const
 243 {
 244   if (left.IsNull())
 245     if (right.IsNull()) return Standard_False;
 246   if (right == myLimits) return Standard_False;
 247   return Standard_True;
 248 }
 249
 250 //=======================================================================
 251 //function : AreaState
 252 //purpose  :
 253 //=======================================================================
 254
 255 TopAbs_State HLRBRep_EdgeBuilder::AreaState() const
 256 {
 257   TopAbs_State stat = TopAbs_UNKNOWN;
 258   if (!left.IsNull())
 259     stat = left->StateAfter();
 260   if (!right.IsNull())
 261     stat = right->StateBefore();
 262   return stat;
 263 }
 264
 265 //=======================================================================
 266 //function : AreaEdgeState
 267 //purpose  :
 268 //=======================================================================
 269
 270 TopAbs_State HLRBRep_EdgeBuilder::AreaEdgeState() const
 271 {
 272   TopAbs_State stat = TopAbs_UNKNOWN;
 273   if (!left.IsNull())
 274     stat = left->EdgeAfter();
 275   if (!right.IsNull())
 276     stat = right->EdgeBefore();
 277   return stat;
 278 }
 279
 280 //=======================================================================
 281 //function : LeftLimit
 282 //purpose  :
 283 //=======================================================================
 284
 285 Handle(HLRBRep_AreaLimit) HLRBRep_EdgeBuilder::LeftLimit() const
 286 {
 287   return left;
 288 }
 289
 290 //=======================================================================
 291 //function : RightLimit
 292 //purpose  :
 293 //=======================================================================
 294
 295 Handle(HLRBRep_AreaLimit) HLRBRep_EdgeBuilder::RightLimit() const
 296 {
 297   return right;
 298 }
 299
 300 //=======================================================================
 301 //function : Builds
 302 //purpose  :
 303 //=======================================================================
 304
 305 void  HLRBRep_EdgeBuilder::Builds(const TopAbs_State ToBuild)
 306 {
 307   toBuild = ToBuild;
 308   InitAreas();
 309   do {
 310     if ((AreaState() == toBuild) &&
 311         (AreaEdgeState() == TopAbs_IN)) {
 312       if (left.IsNull())
 313         current = 2;
 314       else
 315         current = 1;
 316       return;
 317     }
 318     NextArea();
 319   }
 320   while (HasArea());
 321   current = 3;
 322 }
 323
 324 //=======================================================================
 325 //function : MoreEdges
 326 //purpose  :
 327 //=======================================================================
 328
 329 Standard_Boolean  HLRBRep_EdgeBuilder::MoreEdges() const
 330 {
 331   return HasArea();
 332 }
 333
 334 //=======================================================================
 335 //function : NextEdge
 336 //purpose  :
 337 //=======================================================================
 338
 339 void  HLRBRep_EdgeBuilder::NextEdge()
 340 {
 341   // clean the current edge
 342   while (AreaState() == toBuild)
 343     NextArea();
 344   // go to the next edge
 345   while (HasArea()) {
 346     if ((AreaState() == toBuild) &&
 347         (AreaEdgeState() == TopAbs_IN)) {
 348       if (left.IsNull())
 349         current = 2;
 350       else
 351         current = 1;
 352       return;
 353     }
 354     NextArea();
 355   }
 356 }
 357
 358 //=======================================================================
 359 //function : MoreVertices
 360 //purpose  :
 361 //=======================================================================
 362
 363 Standard_Boolean  HLRBRep_EdgeBuilder::MoreVertices() const
 364 {
 365   return (current < 3);
 366 }
 367
 368 //=======================================================================
 369 //function : NextVertex
 370 //purpose  :
 371 //=======================================================================
 372
 373 void  HLRBRep_EdgeBuilder::NextVertex()
 374 {
 375   if (current == 1) {
 376     current = 2;
 377     if (right.IsNull())
 378       current = 3;
 379   }
 380   else if (current == 2) {
 381     NextArea();
 382     if ((AreaState() == toBuild) && (AreaEdgeState() == TopAbs_IN))
 383       current = 2;
 384     else
 385       current = 3;
 386   }
 387   else
 388     throw Standard_NoSuchObject("EdgeBuilder::NextVertex : No current edge");
 389 }
 390
 391 //=======================================================================
 392 //function : Current
 393 //purpose  :
 394 //=======================================================================
 395
 396 const HLRAlgo_Intersection& HLRBRep_EdgeBuilder::Current() const
 397 {
 398   if (current == 1)
 399     return left->Vertex();
 400   else if (current == 2)
 401     return right->Vertex();
 402   else
 403     throw Standard_NoSuchObject("EdgeBuilder::Current : No current vertex");
 404 }
 405
 406 //=======================================================================
 407 //function : IsBoundary
 408 //purpose  :
 409 //=======================================================================
 410
 411 Standard_Boolean  HLRBRep_EdgeBuilder::IsBoundary() const
 412 {
 413   if (current == 1)
 414     return left->IsBoundary();
 415   else if (current == 2)
 416     return right->IsBoundary();
 417   else
 418     throw Standard_NoSuchObject("EdgeBuilder::IsBoundary : No current vertex");
 419 }
 420
 421 //=======================================================================
 422 //function : IsInterference
 423 //purpose  :
 424 //=======================================================================
 425
 426 Standard_Boolean  HLRBRep_EdgeBuilder::IsInterference() const
 427 {
 428   if (current == 1)
 429     return left->IsInterference();
 430   else if (current == 2)
 431     return right->IsInterference();
 432   else
 433     throw Standard_NoSuchObject("EdgeBuilder::IsInterference : No current vertex");
 434 }
 435
 436 //=======================================================================
 437 //function : Orientation
 438 //purpose  :
 439 //=======================================================================
 440
 441 TopAbs_Orientation  HLRBRep_EdgeBuilder::Orientation() const
 442 {
 443   if (current == 1) {
 444     if ((left->StateBefore() == left->StateAfter()) &&
 445         (left->EdgeBefore()  == left->EdgeAfter()))
 446       return TopAbs_INTERNAL;
 447     else
 448       return TopAbs_FORWARD;
 449   }
 450   else if (current == 2) {
 451     if ((right->StateBefore() == right->StateAfter()) &&
 452         (right->EdgeBefore()  == right->EdgeAfter()))
 453       return TopAbs_INTERNAL;
 454     else
 455       return TopAbs_REVERSED;
 456   }
 457   return TopAbs_EXTERNAL; // only for WNT.
 458 }
 459
 460 //=======================================================================
 461 //function : Destroy
 462 //purpose  :
 463 //=======================================================================
 464
 465 void HLRBRep_EdgeBuilder::Destroy()
 466 {
 467   Handle(HLRBRep_AreaLimit) cur = myLimits;
 468   while (!cur.IsNull()) {
 469     Handle(HLRBRep_AreaLimit) n = cur->Next();
 470     cur->Clear();
 471     cur = n;
 472   }
 473   left.Nullify();
 474   right.Nullify();
 475   myLimits.Nullify();
 476 }