1 // Created on: 1991-07-24
2 // Created by: Christophe MARION
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 #include <BRepPrim_OneAxis.ixx>
19 #include <Precision.hxx>
21 #include <TopoDS_Shell.hxx>
22 #include <TopoDS_Face.hxx>
23 #include <TopoDS_Wire.hxx>
24 #include <TopoDS_Edge.hxx>
25 #include <TopoDS_Vertex.hxx>
26 #include <BRepPrim_Builder.hxx>
27 #include <BRepPrim_Direction.hxx>
30 #include <gp_Lin2d.hxx>
31 #include <gp_Circ2d.hxx>
33 #include <gp_Circ.hxx>
36 #include <Standard_DomainError.hxx>
37 #include <Standard_OutOfRange.hxx>
42 #define Standard_True ((Standard_Boolean) 1)
43 #define Standard_False ((Standard_Boolean) 0)
65 #define WLATERALSTART 0
80 //=======================================================================
81 //function : BRepPrim_OneAxis_Check
82 //purpose : raise Standard_DomainError if something was built
83 //=======================================================================
85 static void BRepPrim_OneAxis_Check(const Standard_Boolean V[],
86 const Standard_Boolean E[],
87 const Standard_Boolean W[],
88 const Standard_Boolean F[])
91 for (i = 0; i < NBVERTICES; i++)
92 if (V[i]) Standard_DomainError::Raise();
93 for (i = 0; i < NBEDGES; i++)
94 if (E[i]) Standard_DomainError::Raise();
95 for (i = 0; i < NBWIRES; i++)
96 if (W[i]) Standard_DomainError::Raise();
97 for (i = 0; i < NBFACES; i++)
98 if (F[i]) Standard_DomainError::Raise();
101 //=======================================================================
102 //function : BRepPrim_OneAxis
104 //=======================================================================
106 BRepPrim_OneAxis::BRepPrim_OneAxis(const BRepPrim_Builder& B,
108 const Standard_Real VMin,
109 const Standard_Real VMax) :
120 ShellBuilt = Standard_False;
121 for (i = 0; i < NBVERTICES; i++)
122 VerticesBuilt[i] = Standard_False;
123 for (i = 0; i < NBEDGES; i++)
124 EdgesBuilt[i] = Standard_False;
125 for (i = 0; i < NBWIRES; i++)
126 WiresBuilt[i] = Standard_False;
127 for (i = 0; i < NBFACES; i++)
128 FacesBuilt[i] = Standard_False;
132 //=======================================================================
133 //function : ~BRepPrim_OneAxis
134 //purpose : Destructor
135 //=======================================================================
137 BRepPrim_OneAxis::~BRepPrim_OneAxis()
141 //=======================================================================
142 //function : SetMeridianOffset
144 //=======================================================================
146 void BRepPrim_OneAxis::SetMeridianOffset(const Standard_Real O)
148 myMeridianOffset = O;
151 //=======================================================================
152 //function : Axes, Angle, VMin, VMax
154 //=======================================================================
156 const gp_Ax2& BRepPrim_OneAxis::Axes () const
161 void BRepPrim_OneAxis::Axes (const gp_Ax2& A)
163 BRepPrim_OneAxis_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
167 Standard_Real BRepPrim_OneAxis::Angle () const
172 void BRepPrim_OneAxis::Angle (const Standard_Real A)
174 BRepPrim_OneAxis_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
178 Standard_Real BRepPrim_OneAxis::VMin () const
183 void BRepPrim_OneAxis::VMin (const Standard_Real V)
185 BRepPrim_OneAxis_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
189 Standard_Real BRepPrim_OneAxis::VMax () const
194 void BRepPrim_OneAxis::VMax (const Standard_Real V)
196 BRepPrim_OneAxis_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
200 //=======================================================================
201 //function : MeridianOnAxis
203 //=======================================================================
205 Standard_Boolean BRepPrim_OneAxis::MeridianOnAxis
206 (const Standard_Real V) const
208 return Abs(MeridianValue(V).X()) < Precision::Confusion();
211 //=======================================================================
212 //function : MeridianClosed
214 //=======================================================================
216 Standard_Boolean BRepPrim_OneAxis::MeridianClosed() const
218 if (VMaxInfinite()) return Standard_False;
219 if (VMinInfinite()) return Standard_False;
220 return MeridianValue(myVMin).IsEqual(MeridianValue(myVMax),
221 Precision::Confusion());
224 //=======================================================================
225 //function : VMaxInfinite
227 //=======================================================================
229 Standard_Boolean BRepPrim_OneAxis::VMaxInfinite() const
231 return Precision::IsPositiveInfinite(myVMax);
234 //=======================================================================
235 //function : VMinInfinite
237 //=======================================================================
239 Standard_Boolean BRepPrim_OneAxis::VMinInfinite() const
241 return Precision::IsNegativeInfinite(myVMin);
244 //=======================================================================
247 //=======================================================================
249 Standard_Boolean BRepPrim_OneAxis::HasTop() const
251 if (VMaxInfinite()) return Standard_False;
252 if (MeridianClosed()) return Standard_False;
253 if (MeridianOnAxis(myVMax)) return Standard_False;
254 return Standard_True;
257 //=======================================================================
258 //function : HasBottom
260 //=======================================================================
262 Standard_Boolean BRepPrim_OneAxis::HasBottom() const
264 if (VMinInfinite()) return Standard_False;
265 if (MeridianClosed()) return Standard_False;
266 if (MeridianOnAxis(myVMin)) return Standard_False;
267 return Standard_True;
270 //=======================================================================
271 //function : HasSides
273 //=======================================================================
275 Standard_Boolean BRepPrim_OneAxis::HasSides() const
277 return 2*M_PI - myAngle > Precision::Angular();
280 //=======================================================================
283 //=======================================================================
285 const TopoDS_Shell& BRepPrim_OneAxis::Shell()
288 myBuilder.MakeShell(myShell);
290 myBuilder.AddShellFace(myShell,LateralFace());
292 myBuilder.AddShellFace(myShell,TopFace());
294 myBuilder.AddShellFace(myShell,BottomFace());
296 myBuilder.AddShellFace(myShell,StartFace());
297 myBuilder.AddShellFace(myShell,EndFace());
300 myShell.Closed (BRep_Tool::IsClosed (myShell));
301 myBuilder.CompleteShell(myShell);
302 ShellBuilt = Standard_True;
307 //=======================================================================
308 //function : LateralFace
309 //purpose : build the lateral face
310 //=======================================================================
312 const TopoDS_Face& BRepPrim_OneAxis::LateralFace ()
315 if (!FacesBuilt[FLATERAL]) {
317 // build an empty lateral face
318 myFaces[FLATERAL] = MakeEmptyLateralFace();
321 if (VMaxInfinite() && VMinInfinite()) {
322 myBuilder.AddFaceWire(myFaces[FLATERAL],LateralStartWire());
323 myBuilder.AddFaceWire(myFaces[FLATERAL],LateralEndWire());
326 myBuilder.AddFaceWire(myFaces[FLATERAL],LateralWire());
328 // put the parametric curves
329 if (MeridianClosed()) {
331 myBuilder.SetPCurve(myEdges[ETOP],myFaces[FLATERAL],
332 gp_Lin2d(gp_Pnt2d(0,myVMin),gp_Dir2d(1,0)),
333 gp_Lin2d(gp_Pnt2d(0,myVMax),gp_Dir2d(1,0)));
336 if (!VMaxInfinite()) {
337 myBuilder.SetPCurve(myEdges[ETOP],myFaces[FLATERAL],
338 gp_Lin2d(gp_Pnt2d(0,myVMax),gp_Dir2d(1,0)));
339 if (!HasSides() || MeridianOnAxis(myVMax)) {
340 // closed edge set parameters
341 myBuilder.SetParameters(myEdges[ETOP],
346 if (!VMinInfinite()) {
347 myBuilder.SetPCurve(myEdges[EBOTTOM],myFaces[FLATERAL],
348 gp_Lin2d(gp_Pnt2d(0,myVMin),gp_Dir2d(1,0)));
349 if (!HasSides() || MeridianOnAxis(myVMin)) {
350 // closed edge set parameters
351 myBuilder.SetParameters(myEdges[EBOTTOM],
358 myBuilder.SetPCurve(myEdges[ESTART],myFaces[FLATERAL],
359 gp_Lin2d(gp_Pnt2d(0,-myMeridianOffset),
362 myBuilder.SetPCurve(myEdges[EEND],myFaces[FLATERAL],
363 gp_Lin2d(gp_Pnt2d(myAngle,-myMeridianOffset),
368 myBuilder.SetPCurve(myEdges[ESTART],myFaces[FLATERAL],
369 gp_Lin2d(gp_Pnt2d(myAngle,-myMeridianOffset),
371 gp_Lin2d(gp_Pnt2d(0,-myMeridianOffset),
374 myBuilder.CompleteFace(myFaces[FLATERAL]);
375 FacesBuilt[FLATERAL] = Standard_True;
377 return myFaces[FLATERAL];
380 //=======================================================================
382 //purpose : build and return the TopFace
383 //=======================================================================
385 const TopoDS_Face& BRepPrim_OneAxis::TopFace ()
388 if (!FacesBuilt[FTOP]) {
390 Standard_DomainError_Raise_if(!HasTop(),
391 "BRepPrim_OneAxis::TopFace:No top face");
393 // make the empty face by translating the axes
394 Standard_Real z = MeridianValue(myVMax).Y();
395 gp_Vec V = myAxes.Direction();
397 myBuilder.MakeFace(myFaces[FTOP],gp_Pln(myAxes.Translated(V)));
399 myBuilder.AddFaceWire(myFaces[FTOP],TopWire());
401 // put the parametric curves
402 myBuilder.SetPCurve(myEdges[ETOP],myFaces[FTOP],
403 gp_Circ2d(gp_Ax2d(gp_Pnt2d(0,0),gp_Dir2d(1,0)),
404 MeridianValue(myVMax).X()));
406 myBuilder.SetPCurve(myEdges[ETOPSTART],myFaces[FTOP],
407 gp_Lin2d(gp_Pnt2d(0,0),gp_Dir2d(1,0)));
408 myBuilder.SetPCurve(myEdges[ETOPEND],myFaces[FTOP],
409 gp_Lin2d(gp_Pnt2d(0,0),
410 gp_Dir2d(Cos(myAngle),Sin(myAngle))));
413 myBuilder.CompleteFace(myFaces[FTOP]);
414 FacesBuilt[FTOP] = Standard_True;
417 return myFaces[FTOP];
420 //=======================================================================
421 //function : BottomFace
423 //=======================================================================
425 const TopoDS_Face& BRepPrim_OneAxis::BottomFace ()
428 if (!FacesBuilt[FBOTTOM]) {
430 Standard_DomainError_Raise_if(!HasBottom(),
431 "BRepPrim_OneAxis::BottomFace:No bottom face");
433 // make the empty face by translating the axes
434 Standard_Real z = MeridianValue(myVMin).Y();
435 gp_Vec V = myAxes.Direction();
437 gp_Ax2 axes = myAxes.Translated(V);
438 myBuilder.MakeFace(myFaces[FBOTTOM],gp_Pln(axes));
439 myBuilder.ReverseFace(myFaces[FBOTTOM]);
440 myBuilder.AddFaceWire(myFaces[FBOTTOM],BottomWire());
442 // put the parametric curves
443 myBuilder.SetPCurve(myEdges[EBOTTOM],myFaces[FBOTTOM],
444 gp_Circ2d(gp_Ax2d(gp_Pnt2d(0,0),gp_Dir2d(1,0)),
445 MeridianValue(myVMin).X()));
447 myBuilder.SetPCurve(myEdges[EBOTSTART],myFaces[FBOTTOM],
448 gp_Lin2d(gp_Pnt2d(0,0),gp_Dir2d(1,0)));
449 myBuilder.SetPCurve(myEdges[EBOTEND],myFaces[FBOTTOM],
450 gp_Lin2d(gp_Pnt2d(0,0),
451 gp_Dir2d(Cos(myAngle),Sin(myAngle))));
454 myBuilder.CompleteFace(myFaces[FBOTTOM]);
455 FacesBuilt[FBOTTOM] = Standard_True;
458 return myFaces[FBOTTOM];
461 //=======================================================================
462 //function : StartFace
464 //=======================================================================
466 const TopoDS_Face& BRepPrim_OneAxis::StartFace ()
469 if (!FacesBuilt[FSTART]) {
471 Standard_DomainError_Raise_if(!HasSides(),
472 "BRepPrim_OneAxes::StartFace:No side faces");
474 // build the empty face, perpendicular to myTool.Axes()
475 gp_Ax2 axes(myAxes.Location(),myAxes.YDirection().Reversed(),myAxes.XDirection());
476 myBuilder.MakeFace(myFaces[FSTART],gp_Pln(axes));
479 if (VMaxInfinite() && VMinInfinite())
480 myBuilder.AddFaceWire(myFaces[FSTART],AxisStartWire());
482 myBuilder.AddFaceWire(myFaces[FSTART],StartWire());
485 SetMeridianPCurve(myEdges[ESTART],myFaces[FSTART]);
486 if (EdgesBuilt[EAXIS])
487 myBuilder.SetPCurve(myEdges[EAXIS],myFaces[FSTART],
488 gp_Lin2d(gp_Pnt2d(0,0),gp_Dir2d(0,1)));
489 if (EdgesBuilt[ETOPSTART])
490 myBuilder.SetPCurve(myEdges[ETOPSTART],myFaces[FSTART],
491 gp_Lin2d(gp_Pnt2d(0,MeridianValue(myVMax).Y()),gp_Dir2d(1,0)));
492 if (EdgesBuilt[EBOTSTART])
493 myBuilder.SetPCurve(myEdges[EBOTSTART],myFaces[FSTART],
494 gp_Lin2d(gp_Pnt2d(0,MeridianValue(myVMin).Y()),gp_Dir2d(1,0)));
497 myBuilder.CompleteFace(myFaces[FSTART]);
498 FacesBuilt[FSTART] = Standard_True;
501 return myFaces[FSTART];
504 //=======================================================================
507 //=======================================================================
509 const TopoDS_Face& BRepPrim_OneAxis::EndFace ()
512 if (!FacesBuilt[FEND]) {
514 Standard_DomainError_Raise_if(!HasSides(),
515 "BRepPrim_OneAxes::EndFace:No side faces");
517 // build the empty face, perpendicular to myTool.Axes()
518 gp_Ax2 axes(myAxes.Location(),myAxes.YDirection().Reversed(),myAxes.XDirection());
519 axes.Rotate(myAxes.Axis(),myAngle);
520 myBuilder.MakeFace(myFaces[FEND],gp_Pln(axes));
521 myBuilder.ReverseFace(myFaces[FEND]);
523 if (VMaxInfinite() && VMinInfinite())
524 myBuilder.AddFaceWire(myFaces[FEND],AxisEndWire());
525 myBuilder.AddFaceWire(myFaces[FEND],EndWire());
528 SetMeridianPCurve(myEdges[EEND],myFaces[FEND]);
529 if (EdgesBuilt[EAXIS])
530 myBuilder.SetPCurve(myEdges[EAXIS],myFaces[FEND],
531 gp_Lin2d(gp_Pnt2d(0,0),gp_Dir2d(0,1)));
532 if (EdgesBuilt[ETOPEND])
533 myBuilder.SetPCurve(myEdges[ETOPEND],myFaces[FEND],
534 gp_Lin2d(gp_Pnt2d(0,MeridianValue(myVMax).Y()),
536 if (EdgesBuilt[EBOTEND])
537 myBuilder.SetPCurve(myEdges[EBOTEND],myFaces[FEND],
538 gp_Lin2d(gp_Pnt2d(0,MeridianValue(myVMin).Y()),
541 myBuilder.CompleteFace(myFaces[FEND]);
542 FacesBuilt[FEND] = Standard_True;
545 return myFaces[FEND];
548 //=======================================================================
549 //function : LateralWire
551 //=======================================================================
553 const TopoDS_Wire& BRepPrim_OneAxis::LateralWire ()
556 if (!WiresBuilt[WLATERAL]) {
558 myBuilder.MakeWire(myWires[WLATERAL]);
561 myBuilder.AddWireEdge(myWires[WLATERAL],TopEdge() ,Standard_False);
562 myBuilder.AddWireEdge( myWires[WLATERAL],EndEdge() ,Standard_True);
564 myBuilder.AddWireEdge(myWires[WLATERAL],BottomEdge() ,Standard_True);
565 myBuilder.AddWireEdge( myWires[WLATERAL],StartEdge() ,Standard_False);
567 myBuilder.CompleteWire(myWires[WLATERAL]);
568 WiresBuilt[WLATERAL] = Standard_True;
571 return myWires[WLATERAL];
575 //=======================================================================
576 //function : LateralStartWire
578 //=======================================================================
580 const TopoDS_Wire& BRepPrim_OneAxis::LateralStartWire ()
583 if (!WiresBuilt[WLATERALSTART]) {
585 myBuilder.MakeWire(myWires[WLATERALSTART]);
587 myBuilder.AddWireEdge(myWires[WLATERALSTART],StartEdge(),Standard_False);
589 myBuilder.CompleteWire(myWires[WLATERALSTART]);
590 WiresBuilt[WLATERALSTART] = Standard_True;
593 return myWires[WLATERALSTART];
597 //=======================================================================
598 //function : LateralEndWire
600 //=======================================================================
602 const TopoDS_Wire& BRepPrim_OneAxis::LateralEndWire ()
605 if (!WiresBuilt[WLATERALEND]) {
607 myBuilder.MakeWire(myWires[WLATERALEND]);
609 myBuilder.AddWireEdge(myWires[WLATERALEND],EndEdge(),Standard_True);
611 myBuilder.CompleteWire(myWires[WLATERALEND]);
612 WiresBuilt[WLATERALEND] = Standard_True;
615 return myWires[WLATERALEND];
618 //=======================================================================
621 //=======================================================================
623 const TopoDS_Wire& BRepPrim_OneAxis::TopWire ()
626 if (!WiresBuilt[WTOP]) {
628 Standard_DomainError_Raise_if(!HasTop(),
629 "BRepPrim_OneAxis::TopWire: no top");
631 myBuilder.MakeWire(myWires[WTOP]);
633 myBuilder.AddWireEdge(myWires[WTOP],TopEdge() ,Standard_True);
635 myBuilder.AddWireEdge(myWires[WTOP],StartTopEdge() ,Standard_True);
636 myBuilder.AddWireEdge(myWires[WTOP],EndTopEdge() ,Standard_False);
638 myBuilder.CompleteWire(myWires[WTOP]);
639 WiresBuilt[WTOP] = Standard_True;
642 return myWires[WTOP];
645 //=======================================================================
646 //function : BottomWire
648 //=======================================================================
650 const TopoDS_Wire& BRepPrim_OneAxis::BottomWire ()
653 if (!WiresBuilt[WBOTTOM]) {
655 Standard_DomainError_Raise_if(!HasBottom(),
656 "BRepPrim_OneAxis::BottomWire: no bottom");
658 myBuilder.MakeWire(myWires[WBOTTOM]);
660 myBuilder.AddWireEdge(myWires[WBOTTOM],BottomEdge() ,Standard_False);
662 myBuilder.AddWireEdge(myWires[WBOTTOM],EndBottomEdge() ,Standard_True);
663 myBuilder.AddWireEdge(myWires[WBOTTOM],StartBottomEdge(),Standard_False);
666 myBuilder.CompleteWire(myWires[WBOTTOM]);
667 WiresBuilt[WBOTTOM] = Standard_True;
670 return myWires[WBOTTOM];
673 //=======================================================================
674 //function : StartWire
676 //=======================================================================
678 const TopoDS_Wire& BRepPrim_OneAxis::StartWire ()
681 if (!WiresBuilt[WSTART]) {
683 Standard_DomainError_Raise_if(!HasSides(),
684 "BRepPrim_OneAxes::StartWire:no sides");
686 myBuilder.MakeWire(myWires[WSTART]);
689 myBuilder.AddWireEdge(myWires[WSTART],StartBottomEdge() ,Standard_True);
691 if (!MeridianClosed()) {
692 if (!VMaxInfinite() || !VMinInfinite())
693 myBuilder.AddWireEdge( myWires[WSTART],AxisEdge() ,Standard_False);
697 myBuilder.AddWireEdge(myWires[WSTART],StartTopEdge() ,Standard_False);
698 myBuilder.AddWireEdge( myWires[WSTART],StartEdge() ,Standard_True);
700 myBuilder.CompleteWire(myWires[WSTART]);
701 WiresBuilt[WSTART] = Standard_True;
704 return myWires[WSTART];
707 //=======================================================================
708 //function : AxisStartWire
710 //=======================================================================
712 const TopoDS_Wire& BRepPrim_OneAxis::AxisStartWire ()
715 if (!WiresBuilt[WAXISSTART]) {
717 Standard_DomainError_Raise_if
719 "BRepPrim_OneAxes::AxisStartWire:no sides");
721 Standard_DomainError_Raise_if
722 (!VMaxInfinite() || !VMinInfinite(),
723 "BRepPrim_OneAxes::AxisStartWire:not infinite");
725 Standard_DomainError_Raise_if
727 "BRepPrim_OneAxes::AxisStartWire:meridian closed");
729 myBuilder.MakeWire(myWires[WAXISSTART]);
731 myBuilder.AddWireEdge( myWires[WAXISSTART],AxisEdge() ,Standard_False);
733 myBuilder.CompleteWire(myWires[WAXISSTART]);
734 WiresBuilt[WAXISSTART] = Standard_True;
737 return myWires[WAXISSTART];
740 //=======================================================================
743 //=======================================================================
745 const TopoDS_Wire& BRepPrim_OneAxis::EndWire ()
748 if (!WiresBuilt[WEND]) {
750 Standard_DomainError_Raise_if(!HasSides(),
751 "BRepPrim_OneAxes::EndWire:no sides");
753 myBuilder.MakeWire(myWires[WEND]);
756 myBuilder.AddWireEdge(myWires[WEND],EndTopEdge(), Standard_True);
757 if (!MeridianClosed()) {
758 if (!VMaxInfinite() || !VMinInfinite()) {
759 myBuilder.AddWireEdge( myWires[WEND],AxisEdge(), Standard_True);
763 myBuilder.AddWireEdge(myWires[WEND],EndBottomEdge(), Standard_False);
764 myBuilder.AddWireEdge( myWires[WEND],EndEdge(), Standard_False);
766 myBuilder.CompleteWire(myWires[WEND]);
767 WiresBuilt[WEND] = Standard_True;
769 return myWires[WEND];
772 //=======================================================================
773 //function : AxisEndWire
775 //=======================================================================
777 const TopoDS_Wire& BRepPrim_OneAxis::AxisEndWire ()
780 if (!WiresBuilt[WAXISEND]) {
782 Standard_DomainError_Raise_if
784 "BRepPrim_OneAxes::AxisEndWire:no sides");
786 Standard_DomainError_Raise_if
787 (!VMaxInfinite() || !VMinInfinite(),
788 "BRepPrim_OneAxes::AxisEndWire:not infinite");
790 Standard_DomainError_Raise_if
792 "BRepPrim_OneAxes::AxisEndWire:meridian closed");
794 myBuilder.MakeWire(myWires[WAXISEND]);
796 myBuilder.AddWireEdge( myWires[WAXISEND],AxisEdge(), Standard_True);
798 myBuilder.CompleteWire(myWires[WAXISEND]);
799 WiresBuilt[WAXISEND] = Standard_True;
801 return myWires[WAXISEND];
804 //=======================================================================
805 //function : AxisEdge
806 //purpose : make the edge on the axis, oriented +Z
807 //=======================================================================
809 const TopoDS_Edge& BRepPrim_OneAxis::AxisEdge ()
812 if (!EdgesBuilt[EAXIS]) {
814 Standard_DomainError_Raise_if(!HasSides(),
815 "BRepPrim_OneAxis::AxisEdge:no sides");
816 Standard_DomainError_Raise_if(MeridianClosed(),
817 "BRepPrim_OneAxis::AxisEdge:closed");
819 // build the empty edge.
820 myBuilder.MakeEdge(myEdges[EAXIS],gp_Lin(myAxes.Axis()));
823 myBuilder.AddEdgeVertex(myEdges[EAXIS],AxisTopVertex(),
824 MeridianValue(myVMax).Y(),Standard_False);
826 myBuilder.AddEdgeVertex(myEdges[EAXIS],AxisBottomVertex(),
827 MeridianValue(myVMin).Y(),Standard_True);
829 myBuilder.CompleteEdge(myEdges[EAXIS]);
830 EdgesBuilt[EAXIS] = Standard_True;
833 return myEdges[EAXIS];
836 //=======================================================================
837 //function : StartEdge
839 //=======================================================================
841 const TopoDS_Edge& BRepPrim_OneAxis::StartEdge ()
844 if (!EdgesBuilt[ESTART]) {
846 // is it shared with the EndEdge
848 if (!HasSides() && EdgesBuilt[EEND])
849 myEdges[ESTART] = myEdges[EEND];
852 // build the empty Edge
853 myEdges[ESTART] = MakeEmptyMeridianEdge(0.);
855 if (MeridianClosed()) {
857 myBuilder.AddEdgeVertex(myEdges[ESTART],
859 myVMin+myMeridianOffset,
860 myVMax+myMeridianOffset);
863 if (!VMaxInfinite()) {
864 myBuilder.AddEdgeVertex(myEdges[ESTART],
866 myVMax+myMeridianOffset,
869 if (!VMinInfinite()) {
870 myBuilder.AddEdgeVertex(myEdges[ESTART],
872 myVMin+myMeridianOffset,
878 myBuilder.CompleteEdge(myEdges[ESTART]);
879 EdgesBuilt[ESTART] = Standard_True;
883 return myEdges[ESTART];
886 //=======================================================================
889 //=======================================================================
891 const TopoDS_Edge& BRepPrim_OneAxis::EndEdge ()
894 if (!EdgesBuilt[EEND]) {
896 // is it shared with the start edge
897 if (!HasSides() && EdgesBuilt[ESTART])
898 myEdges[EEND] = myEdges[ESTART];
901 // build the empty Edge
902 myEdges[EEND] = MakeEmptyMeridianEdge(myAngle);
905 if (MeridianClosed()) {
907 myBuilder.AddEdgeVertex(myEdges[EEND],
909 myVMin+myMeridianOffset,
910 myVMax+myMeridianOffset);
913 if (!VMaxInfinite()) {
914 myBuilder.AddEdgeVertex(myEdges[EEND],
916 myVMax+myMeridianOffset,
919 if (!VMinInfinite()) {
920 myBuilder.AddEdgeVertex(myEdges[EEND],
922 myVMin+myMeridianOffset,
928 myBuilder.CompleteEdge(myEdges[EEND]);
929 EdgesBuilt[EEND] = Standard_True;
933 return myEdges[EEND];
936 //=======================================================================
937 //function : StartTopEdge
939 //=======================================================================
941 const TopoDS_Edge& BRepPrim_OneAxis::StartTopEdge ()
944 if (!EdgesBuilt[ETOPSTART]) {
946 Standard_DomainError_Raise_if
947 (!HasTop() || !HasSides(),
948 "BRepPrim_OneAxis::StartTopEdge:no sides or no top");
950 // build the empty Edge
951 gp_Vec V = myAxes.Direction();
952 V.Multiply(MeridianValue(myVMax).Y());
953 gp_Pnt P = myAxes.Location().Translated(V);
954 myBuilder.MakeEdge(myEdges[ETOPSTART],gp_Lin(P,myAxes.XDirection()));
956 myBuilder.AddEdgeVertex(myEdges[ETOPSTART],AxisTopVertex(),
958 myBuilder.AddEdgeVertex(myEdges[ETOPSTART],TopStartVertex(),
959 MeridianValue(myVMax).X(),Standard_False);
961 myBuilder.CompleteEdge(myEdges[ETOPSTART]);
962 EdgesBuilt[ETOPSTART] = Standard_True;
965 return myEdges[ETOPSTART];
968 //=======================================================================
969 //function : StartBottomEdge
971 //=======================================================================
973 const TopoDS_Edge& BRepPrim_OneAxis::StartBottomEdge ()
976 if (!EdgesBuilt[EBOTSTART]) {
978 Standard_DomainError_Raise_if
979 (!HasBottom() || !HasSides(),
980 "BRepPrim_OneAxis::StartBottomEdge:no sides or no top");
982 // build the empty Edge
983 gp_Vec V = myAxes.Direction();
984 V.Multiply(MeridianValue(myVMin).Y());
985 gp_Pnt P = myAxes.Location().Translated(V);
986 myBuilder.MakeEdge(myEdges[EBOTSTART],gp_Lin(P,myAxes.XDirection()));
988 myBuilder.AddEdgeVertex(myEdges[EBOTSTART],BottomStartVertex(),
989 MeridianValue(myVMin).X(),Standard_False);
990 myBuilder.AddEdgeVertex(myEdges[EBOTSTART],AxisBottomVertex(),
993 myBuilder.CompleteEdge(myEdges[EBOTSTART]);
994 EdgesBuilt[EBOTSTART] = Standard_True;
997 return myEdges[EBOTSTART];
1000 //=======================================================================
1001 //function : EndTopEdge
1003 //=======================================================================
1005 const TopoDS_Edge& BRepPrim_OneAxis::EndTopEdge ()
1007 // do it if not done
1008 if (!EdgesBuilt[ETOPEND]) {
1010 Standard_DomainError_Raise_if
1011 (!HasTop() || !HasSides(),
1012 "BRepPrim_OneAxis::EndTopEdge:no sides or no top");
1014 // build the empty Edge
1015 gp_Vec V = myAxes.Direction();
1016 V.Multiply(MeridianValue(myVMax).Y());
1017 gp_Pnt P = myAxes.Location().Translated(V);
1018 gp_Lin L(P,myAxes.XDirection());
1019 L.Rotate(myAxes.Axis(),myAngle);
1020 myBuilder.MakeEdge(myEdges[ETOPEND],L);
1022 myBuilder.AddEdgeVertex(myEdges[ETOPEND],AxisTopVertex(),
1024 myBuilder.AddEdgeVertex(myEdges[ETOPEND],TopEndVertex(),
1025 MeridianValue(myVMax).X(),Standard_False);
1027 myBuilder.CompleteEdge(myEdges[ETOPEND]);
1028 EdgesBuilt[ETOPEND] = Standard_True;
1031 return myEdges[ETOPEND];
1034 //=======================================================================
1035 //function : EndBottomEdge
1037 //=======================================================================
1039 const TopoDS_Edge& BRepPrim_OneAxis::EndBottomEdge ()
1041 // do it if not done
1042 if (!EdgesBuilt[EBOTEND]) {
1045 Standard_DomainError_Raise_if
1046 (!HasBottom() || !HasSides(),
1047 "BRepPrim_OneAxis::EndBottomEdge:no sides or no bottom");
1049 // build the empty Edge
1050 gp_Vec V = myAxes.Direction();
1051 V.Multiply(MeridianValue(myVMin).Y());
1052 gp_Pnt P = myAxes.Location().Translated(V);
1053 gp_Lin L(P,myAxes.XDirection());
1054 L.Rotate(myAxes.Axis(),myAngle);
1055 myBuilder.MakeEdge(myEdges[EBOTEND],L);
1057 myBuilder.AddEdgeVertex(myEdges[EBOTEND],AxisBottomVertex(),
1059 myBuilder.AddEdgeVertex(myEdges[EBOTEND],BottomEndVertex(),
1060 MeridianValue(myVMin).X(),Standard_False);
1062 myBuilder.CompleteEdge(myEdges[EBOTEND]);
1063 EdgesBuilt[EBOTEND] = Standard_True;
1066 return myEdges[EBOTEND];
1069 //=======================================================================
1070 //function : TopEdge
1072 //=======================================================================
1074 const TopoDS_Edge& BRepPrim_OneAxis::TopEdge ()
1076 // do it if not done
1077 if (!EdgesBuilt[ETOP]) {
1079 // Test if shared with bottom edge
1080 if (MeridianClosed() && EdgesBuilt[EBOTTOM]) {
1081 myEdges[ETOP] = myEdges[EBOTTOM];
1086 // build the empty Edge
1087 if (!MeridianOnAxis(myVMax)) {
1088 gp_Pnt2d mp = MeridianValue(myVMax);
1089 gp_Vec V = myAxes.Direction();
1091 gp_Pnt P = myAxes.Location().Translated(V);
1092 gp_Circ C(gp_Ax2(P,myAxes.Direction(),myAxes.XDirection()),mp.X());
1093 myBuilder.MakeEdge(myEdges[ETOP],C);
1096 myBuilder.MakeDegeneratedEdge(myEdges[ETOP]);
1100 myBuilder.AddEdgeVertex(myEdges[ETOP],
1105 myBuilder.AddEdgeVertex(myEdges[ETOP],
1109 myBuilder.AddEdgeVertex(myEdges[ETOP],
1116 myBuilder.CompleteEdge(myEdges[ETOP]);
1117 EdgesBuilt[ETOP] = Standard_True;
1120 return myEdges[ETOP];
1123 //=======================================================================
1124 //function : BottomEdge
1126 //=======================================================================
1128 const TopoDS_Edge& BRepPrim_OneAxis::BottomEdge ()
1130 // do it if not done
1131 if (!EdgesBuilt[EBOTTOM]) {
1133 // Test if shared with top edge
1134 if (MeridianClosed() && EdgesBuilt[ETOP]) {
1135 myEdges[EBOTTOM] = myEdges[ETOP];
1140 // build the empty Edge
1142 if (!MeridianOnAxis(myVMin)) {
1143 gp_Pnt2d mp = MeridianValue(myVMin);
1144 gp_Vec V = myAxes.Direction();
1146 gp_Pnt P = myAxes.Location().Translated(V);
1147 gp_Circ C(gp_Ax2(P,myAxes.Direction(),myAxes.XDirection()),mp.X());
1148 myBuilder.MakeEdge(myEdges[EBOTTOM],C);
1151 myBuilder.MakeDegeneratedEdge(myEdges[EBOTTOM]);
1155 myBuilder.AddEdgeVertex(myEdges[EBOTTOM],
1160 myBuilder.AddEdgeVertex(myEdges[EBOTTOM],
1164 myBuilder.AddEdgeVertex(myEdges[EBOTTOM],
1165 BottomStartVertex(),
1171 myBuilder.CompleteEdge(myEdges[EBOTTOM]);
1172 EdgesBuilt[EBOTTOM] = Standard_True;
1175 return myEdges[EBOTTOM];
1178 //=======================================================================
1179 //function : AxisTopVertex
1181 //=======================================================================
1183 const TopoDS_Vertex& BRepPrim_OneAxis::AxisTopVertex ()
1185 // do it if not done
1186 if (!VerticesBuilt[VAXISTOP]) {
1188 // deduct from others
1189 if (MeridianOnAxis(myVMax) && VerticesBuilt[VTOPSTART])
1190 myVertices[VAXISTOP] = myVertices[VTOPSTART];
1192 else if (MeridianOnAxis(myVMax) && VerticesBuilt[VTOPEND])
1193 myVertices[VAXISTOP] = myVertices[VTOPEND];
1196 Standard_DomainError_Raise_if(MeridianClosed(),
1197 "BRepPrim_OneAxis::AxisTopVertex");
1198 Standard_DomainError_Raise_if(VMaxInfinite(),
1199 "BRepPrim_OneAxis::AxisTopVertex");
1201 gp_Vec V = myAxes.Direction();
1202 V.Multiply(MeridianValue(myVMax).Y());
1203 gp_Pnt P = myAxes.Location().Translated(V);
1204 myBuilder.MakeVertex(myVertices[VAXISTOP],P);
1207 VerticesBuilt[VAXISTOP] = Standard_True;
1210 return myVertices[VAXISTOP];
1213 //=======================================================================
1214 //function : AxisBottomVertex
1216 //=======================================================================
1218 const TopoDS_Vertex& BRepPrim_OneAxis::AxisBottomVertex ()
1220 // do it if not done
1221 if (!VerticesBuilt[VAXISBOT]) {
1223 // deduct from others
1224 if (MeridianOnAxis(myVMin) && VerticesBuilt[VBOTSTART])
1225 myVertices[VAXISBOT] = myVertices[VBOTSTART];
1227 else if (MeridianOnAxis(myVMin) && VerticesBuilt[VBOTEND])
1228 myVertices[VAXISBOT] = myVertices[VBOTEND];
1231 Standard_DomainError_Raise_if(MeridianClosed(),
1232 "BRepPrim_OneAxis::AxisBottomVertex");
1233 Standard_DomainError_Raise_if(VMinInfinite(),
1234 "BRepPrim_OneAxis::AxisBottomVertex");
1236 gp_Vec V = myAxes.Direction();
1237 V.Multiply(MeridianValue(myVMin).Y());
1238 gp_Pnt P = myAxes.Location().Translated(V);
1239 myBuilder.MakeVertex(myVertices[VAXISBOT],P);
1242 VerticesBuilt[VAXISBOT] = Standard_True;
1245 return myVertices[VAXISBOT];
1248 //=======================================================================
1249 //function : TopStartVertex
1251 //=======================================================================
1253 const TopoDS_Vertex& BRepPrim_OneAxis::TopStartVertex ()
1255 // do it if not done
1256 if (!VerticesBuilt[VTOPSTART]) {
1258 // deduct from others
1259 if (MeridianOnAxis(myVMax) && VerticesBuilt[VAXISTOP])
1260 myVertices[VTOPSTART] = myVertices[VAXISTOP];
1261 else if ((MeridianOnAxis(myVMax) || !HasSides()) && VerticesBuilt[VTOPEND])
1262 myVertices[VTOPSTART] = myVertices[VTOPEND];
1263 else if (MeridianClosed() && VerticesBuilt[VBOTSTART])
1264 myVertices[VTOPSTART] = myVertices[VBOTSTART];
1265 else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VBOTEND])
1266 myVertices[VTOPSTART] = myVertices[VBOTEND];
1269 gp_Pnt2d mp = MeridianValue(myVMax);
1270 gp_Vec V = myAxes.Direction();
1272 gp_Pnt P = myAxes.Location().Translated(V);
1273 V = myAxes.XDirection();
1276 myBuilder.MakeVertex(myVertices[VTOPSTART],P);
1279 VerticesBuilt[VTOPSTART] = Standard_True;
1282 return myVertices[VTOPSTART];
1285 //=======================================================================
1286 //function : TopEndVertex
1288 //=======================================================================
1290 const TopoDS_Vertex& BRepPrim_OneAxis::TopEndVertex ()
1292 // do it if not done
1293 if (!VerticesBuilt[VTOPEND]) {
1296 // deduct from others
1297 if (MeridianOnAxis(myVMax) && VerticesBuilt[VAXISTOP])
1298 myVertices[VTOPEND] = myVertices[VAXISTOP];
1299 else if ((MeridianOnAxis(myVMax) || !HasSides()) && VerticesBuilt[VTOPSTART])
1300 myVertices[VTOPEND] = myVertices[VTOPSTART];
1301 else if (MeridianClosed() && VerticesBuilt[VBOTEND])
1302 myVertices[VTOPEND] = myVertices[VBOTEND];
1303 else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VBOTSTART])
1304 myVertices[VTOPEND] = myVertices[VBOTSTART];
1307 gp_Pnt2d mp = MeridianValue(myVMax);
1308 gp_Vec V = myAxes.Direction();
1310 gp_Pnt P = myAxes.Location().Translated(V);
1311 V = myAxes.XDirection();
1314 P.Rotate(myAxes.Axis(),myAngle);
1315 myBuilder.MakeVertex(myVertices[VTOPEND],P);
1318 VerticesBuilt[VTOPEND] = Standard_True;
1321 return myVertices[VTOPEND];
1324 //=======================================================================
1325 //function : BottomStartVertex
1327 //=======================================================================
1329 const TopoDS_Vertex& BRepPrim_OneAxis::BottomStartVertex ()
1331 // do it if not done
1332 if (!VerticesBuilt[VBOTSTART]) {
1334 // deduct from others
1335 if (MeridianOnAxis(myVMin) && VerticesBuilt[VAXISBOT])
1336 myVertices[VBOTSTART] = myVertices[VAXISBOT];
1337 else if ((MeridianOnAxis(myVMin) || !HasSides()) && VerticesBuilt[VBOTEND])
1338 myVertices[VBOTSTART] = myVertices[VBOTEND];
1339 else if (MeridianClosed() && VerticesBuilt[VTOPSTART])
1340 myVertices[VBOTSTART] = myVertices[VTOPSTART];
1341 else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VTOPEND])
1342 myVertices[VBOTSTART] = myVertices[VTOPEND];
1345 gp_Pnt2d mp = MeridianValue(myVMin);
1346 gp_Vec V = myAxes.Direction();
1348 gp_Pnt P = myAxes.Location().Translated(V);
1349 V = myAxes.XDirection();
1352 myBuilder.MakeVertex(myVertices[VBOTSTART],P);
1355 VerticesBuilt[VBOTSTART] = Standard_True;
1358 return myVertices[VBOTSTART];
1361 //=======================================================================
1362 //function : BottomEndVertex
1364 //=======================================================================
1366 const TopoDS_Vertex& BRepPrim_OneAxis::BottomEndVertex ()
1368 // do it if not done
1369 if (!VerticesBuilt[VBOTEND]) {
1371 // deduct from others
1372 if (MeridianOnAxis(myVMin) && VerticesBuilt[VAXISBOT])
1373 myVertices[VBOTEND] = myVertices[VAXISBOT];
1374 else if ((MeridianOnAxis(myVMin) || !HasSides()) && VerticesBuilt[VBOTSTART])
1375 myVertices[VBOTEND] = myVertices[VBOTSTART];
1376 else if (MeridianClosed() && VerticesBuilt[VTOPEND])
1377 myVertices[VBOTEND] = myVertices[VTOPEND];
1378 else if (MeridianClosed() && !HasSides() && VerticesBuilt[VTOPSTART])
1379 myVertices[VBOTEND] = myVertices[VTOPSTART];
1382 gp_Pnt2d mp = MeridianValue(myVMin);
1383 gp_Vec V = myAxes.Direction();
1385 gp_Pnt P = myAxes.Location().Translated(V);
1386 V = myAxes.XDirection();
1389 P.Rotate(myAxes.Axis(),myAngle);
1390 myBuilder.MakeVertex(myVertices[VBOTEND],P);
1393 VerticesBuilt[VBOTEND] = Standard_True;
1396 return myVertices[VBOTEND];