0028643: Coding rules - eliminate GCC compiler warnings -Wmisleading-indentation
[occt.git] / src / BRepPrim / BRepPrim_GWedge.cxx
1 // Created on: 1991-09-27
2 // Created by: Christophe MARION
3 // Copyright (c) 1991-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
18 #include <BRepPrim_Builder.hxx>
19 #include <BRepPrim_Direction.hxx>
20 #include <BRepPrim_GWedge.hxx>
21 #include <ElCLib.hxx>
22 #include <ElSLib.hxx>
23 #include <gp_Ax2.hxx>
24 #include <gp_Lin.hxx>
25 #include <gp_Pln.hxx>
26 #include <gp_Pnt.hxx>
27 #include <gp_Vec.hxx>
28 #include <Precision.hxx>
29 #include <Standard_DomainError.hxx>
30 #include <Standard_OutOfRange.hxx>
31 #include <TopoDS_Edge.hxx>
32 #include <TopoDS_Face.hxx>
33 #include <TopoDS_Shell.hxx>
34 #include <TopoDS_Vertex.hxx>
35 #include <TopoDS_Wire.hxx>
36
37 #define NBFACES 6
38 #define NBWIRES 6
39 #define NBEDGES 12
40 #define NBVERTICES 8
41
42 static const Standard_Integer num[6] = {0,1,2,3,4,5};
43 static const Standard_Integer val[6] = {0,4,0,2,0,1};
44 static const Standard_Integer tab[6][6] = {{-1,-1, 0, 1, 8, 9},
45                                            {-1,-1, 2, 3,10,11},
46                                            { 0, 2,-1,-1, 4, 5},
47                                            { 1, 3,-1,-1, 6, 7},
48                                            { 8,10, 4, 6,-1,-1},
49                                            { 9,11, 5, 7,-1,-1}};
50
51 //=======================================================================
52 //function : BRepPrim_Wedge_NumDir1
53 //purpose  : when giving a direction return the range of the face
54 //=======================================================================
55
56 static Standard_Integer BRepPrim_Wedge_NumDir1
57   (const BRepPrim_Direction d1) { return num[d1]; }
58
59 //=======================================================================
60 //function : BRepPrim_Wedge_NumDir2
61 //purpose  : when giving two directions return the range of the edge
62 //=======================================================================
63
64 static Standard_Integer BRepPrim_Wedge_NumDir2
65   (const BRepPrim_Direction d1,
66    const BRepPrim_Direction d2)
67 {
68   Standard_Integer i1 = BRepPrim_Wedge_NumDir1(d1);
69   Standard_Integer i2 = BRepPrim_Wedge_NumDir1(d2);
70   if ( i1/2 == i2/2 ) throw Standard_DomainError();
71   return tab[i1][i2];
72 }
73
74 //=======================================================================
75 //function : BRepPrim_Wedge_NumDir3
76 //purpose  : when giving three directions return the range of the vertex
77 //=======================================================================
78
79 static Standard_Integer BRepPrim_Wedge_NumDir3
80   (const BRepPrim_Direction d1,
81    const BRepPrim_Direction d2,
82    const BRepPrim_Direction d3)
83 {
84   Standard_Integer i1 = BRepPrim_Wedge_NumDir1(d1);
85   Standard_Integer i2 = BRepPrim_Wedge_NumDir1(d2);
86   Standard_Integer i3 = BRepPrim_Wedge_NumDir1(d3);
87   if (( i1/2 == i2/2 ) ||
88       ( i2/2 == i3/2 ) ||
89       ( i3/2 == i1/2 )) throw Standard_DomainError();
90   return val[i1]+val[i2]+val[i3];
91 }
92
93 //=======================================================================
94 //function : BRepPrim_Wedge_Check
95 //purpose  : raise Standard_DomainError if something was built
96 //=======================================================================
97
98 static void BRepPrim_Wedge_Check(const Standard_Boolean V[],
99                                    const Standard_Boolean E[],
100                                    const Standard_Boolean W[],
101                                    const Standard_Boolean F[])
102 {
103   Standard_Integer i;
104   for (i = 0; i < NBVERTICES; i++)
105     if (V[i]) throw Standard_DomainError();
106   for (i = 0; i < NBEDGES; i++)
107     if (E[i]) throw Standard_DomainError();
108   for (i = 0; i < NBWIRES; i++)
109     if (W[i]) throw Standard_DomainError();
110   for (i = 0; i < NBFACES; i++)
111     if (F[i]) throw Standard_DomainError();
112 }
113
114 //=======================================================================
115 //function : BRepPrim_Wedge_Init
116 //purpose  : Set arrays to Standard_False
117 //=======================================================================
118
119 static void BRepPrim_Wedge_Init(Standard_Boolean& S,
120                                   Standard_Boolean V[],
121                                   Standard_Boolean E[],
122                                   Standard_Boolean W[],
123                                   Standard_Boolean F[])
124 {
125   Standard_Integer i;
126   S = Standard_False;
127   for (i = 0; i < NBVERTICES; i++)
128     V[i] = Standard_False;
129   for (i = 0; i < NBEDGES; i++)
130     E[i] = Standard_False;
131   for (i = 0; i < NBWIRES; i++)
132     W[i] = Standard_False;
133   for (i = 0; i < NBFACES; i++)
134     F[i] = Standard_False;
135 }
136
137 //=======================================================================
138 //function : BRepPrim_GWedge
139 //purpose  : build a box
140 //=======================================================================
141
142 BRepPrim_GWedge::BRepPrim_GWedge (const BRepPrim_Builder& B,
143                                     const gp_Ax2& Axes,
144                                     const Standard_Real dx,
145                                     const Standard_Real dy,
146                                     const Standard_Real dz) :
147        myBuilder(B),
148        myAxes(Axes),
149        XMin(0),
150        XMax(dx),
151        YMin(0),
152        YMax(dy),
153        ZMin(0),
154        ZMax(dz),
155        Z2Min(0),
156        Z2Max(dz),
157        X2Min(0),
158        X2Max(dx)
159 {
160   for (Standard_Integer i = 0; i < NBFACES; i++) { myInfinite[i]=Standard_False; }
161   if ( ( dx <= Precision::Confusion() ) ||
162        ( dy <= Precision::Confusion() ) ||
163        ( dz <= Precision::Confusion() ) )
164     throw Standard_DomainError();
165   BRepPrim_Wedge_Init(ShellBuilt,VerticesBuilt,EdgesBuilt,
166                         WiresBuilt,FacesBuilt);
167 }
168
169 //=======================================================================
170 //function : BRepPrim_GWedge
171 //purpose  : build a STEP wedge
172 //=======================================================================
173
174 BRepPrim_GWedge::BRepPrim_GWedge (const BRepPrim_Builder& B,
175                                     const gp_Ax2& Axes,
176                                     const Standard_Real dx,
177                                     const Standard_Real dy,
178                                     const Standard_Real dz,
179                                     const Standard_Real ltx) :
180        myBuilder(B),
181        myAxes(Axes),
182        XMin(0),
183        XMax(dx),
184        YMin(0),
185        YMax(dy),
186        ZMin(0),
187        ZMax(dz),
188        Z2Min(0),
189        Z2Max(dz),
190        X2Min(0),
191        X2Max(ltx)
192 {
193   for (Standard_Integer i = 0; i < NBFACES; i++) { myInfinite[i]=Standard_False; }
194   if ( ( dx <= Precision::Confusion() ) ||
195        ( dy <= Precision::Confusion() ) ||
196        ( dz <= Precision::Confusion() ) ||
197        ( ltx < 0 ) )
198     throw Standard_DomainError();
199   BRepPrim_Wedge_Init(ShellBuilt,VerticesBuilt,EdgesBuilt,
200                         WiresBuilt,FacesBuilt);
201 }
202
203 //=======================================================================
204 //function : BRepPrim_GWedge
205 //purpose  : build a wedge by giving all the fields
206 //=======================================================================
207
208 BRepPrim_GWedge::BRepPrim_GWedge (const BRepPrim_Builder& B,
209                                     const gp_Ax2& Axes,
210                                     const Standard_Real xmin,
211                                     const Standard_Real ymin,
212                                     const Standard_Real zmin,
213                                     const Standard_Real z2min,
214                                     const Standard_Real x2min,
215                                     const Standard_Real xmax,
216                                     const Standard_Real ymax,
217                                     const Standard_Real zmax,
218                                     const Standard_Real z2max,
219                                     const Standard_Real x2max) :
220        myBuilder(B),
221        myAxes(Axes),
222        XMin(xmin),
223        XMax(xmax),
224        YMin(ymin),
225        YMax(ymax),
226        ZMin(zmin),
227        ZMax(zmax),
228        Z2Min(z2min),
229        Z2Max(z2max),
230        X2Min(x2min),
231        X2Max(x2max)
232 {
233   for (Standard_Integer i = 0; i < NBFACES; i++) { myInfinite[i]=Standard_False; }
234   if ( ( XMax-XMin <= Precision::Confusion() ) ||
235        ( YMax-YMin <= Precision::Confusion() ) ||
236        ( ZMax-ZMin <= Precision::Confusion() ) ||
237        ( Z2Max-Z2Min < 0 ) ||
238        ( X2Max-X2Min < 0 ) )
239     throw Standard_DomainError();
240   BRepPrim_Wedge_Init(ShellBuilt,VerticesBuilt,EdgesBuilt,
241                         WiresBuilt,FacesBuilt);
242 }
243
244 //=======================================================================
245 //function : Axes,
246 //           GetXMin, GetYMin, GetZMin, GetZ2Min, GetX2Min
247 //           GetXMax, GetYMax, GetZMax, GetZ2Max, GetX2Max
248 //purpose  : trivial
249 //=======================================================================
250
251 gp_Ax2 BRepPrim_GWedge::Axes     () const { return myAxes; }
252 Standard_Real   BRepPrim_GWedge::GetXMin  () const { return XMin;   }
253 Standard_Real   BRepPrim_GWedge::GetYMin  () const { return YMin;   }
254 Standard_Real   BRepPrim_GWedge::GetZMin  () const { return ZMin;   }
255 Standard_Real   BRepPrim_GWedge::GetZ2Min () const { return Z2Min;  }
256 Standard_Real   BRepPrim_GWedge::GetX2Min () const { return X2Min;  }
257 Standard_Real   BRepPrim_GWedge::GetXMax  () const { return XMax;   }
258 Standard_Real   BRepPrim_GWedge::GetYMax  () const { return YMax;   }
259 Standard_Real   BRepPrim_GWedge::GetZMax  () const { return ZMax;   }
260 Standard_Real   BRepPrim_GWedge::GetZ2Max () const { return Z2Max;  }
261 Standard_Real   BRepPrim_GWedge::GetX2Max () const { return X2Max;  }
262
263 //=======================================================================
264 //function : Open
265 //purpose  : trivial
266 //=======================================================================
267
268 void BRepPrim_GWedge::Open (const BRepPrim_Direction d1)
269 {
270   BRepPrim_Wedge_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
271   myInfinite[BRepPrim_Wedge_NumDir1(d1)] = Standard_True;
272 }
273
274 //=======================================================================
275 //function : Close
276 //purpose  : trivial
277 //=======================================================================
278
279 void BRepPrim_GWedge::Close (const BRepPrim_Direction d1)
280 {
281   BRepPrim_Wedge_Check(VerticesBuilt,EdgesBuilt,WiresBuilt,FacesBuilt);
282   myInfinite[BRepPrim_Wedge_NumDir1(d1)] = Standard_False;
283 }
284
285 //=======================================================================
286 //function : IsInfinite
287 //purpose  : true if it is open in the given direction
288 //=======================================================================
289
290 Standard_Boolean BRepPrim_GWedge::IsInfinite (const BRepPrim_Direction d1) const
291 { return myInfinite[BRepPrim_Wedge_NumDir1(d1)]; }
292
293 //=======================================================================
294 //function : Shell
295 //purpose  : 
296 //=======================================================================
297
298 const TopoDS_Shell& BRepPrim_GWedge::Shell() {
299   if (!ShellBuilt) {
300     myBuilder.MakeShell(myShell);
301
302     if (HasFace(BRepPrim_XMin))
303       myBuilder.AddShellFace(myShell,Face(BRepPrim_XMin));
304     if (HasFace(BRepPrim_XMax))
305       myBuilder.AddShellFace(myShell,Face(BRepPrim_XMax));
306     if (HasFace(BRepPrim_YMin))
307       myBuilder.AddShellFace(myShell,Face(BRepPrim_YMin));
308     if (HasFace(BRepPrim_YMax))
309       myBuilder.AddShellFace(myShell,Face(BRepPrim_YMax));
310     if (HasFace(BRepPrim_ZMin))
311       myBuilder.AddShellFace(myShell,Face(BRepPrim_ZMin));
312     if (HasFace(BRepPrim_ZMax))
313       myBuilder.AddShellFace(myShell,Face(BRepPrim_ZMax));
314
315     myShell.Closed (BRep_Tool::IsClosed (myShell));
316     myBuilder.CompleteShell(myShell);
317     ShellBuilt = Standard_True;
318   }
319   return myShell;
320 }
321
322 //=======================================================================
323 //function : HasFace 
324 //purpose  : true if the face exist in one direction
325 //=======================================================================
326
327 Standard_Boolean BRepPrim_GWedge::HasFace (const BRepPrim_Direction d1) const
328
329   Standard_Boolean state = !myInfinite[BRepPrim_Wedge_NumDir1(d1)]; 
330   if ( d1 == BRepPrim_YMax ) state = state && ( Z2Max != Z2Min )
331                                              && ( X2Max != X2Min );
332   return state;
333 }
334
335 //=======================================================================
336 //function : Plane
337 //purpose  : 
338 //=======================================================================
339
340 gp_Pln BRepPrim_GWedge::Plane(const BRepPrim_Direction d1)
341 {
342
343   Standard_Integer i = BRepPrim_Wedge_NumDir1(d1);
344
345   gp_Dir D;
346   gp_Vec VX = myAxes.XDirection();
347   gp_Vec VY = myAxes.YDirection();
348   gp_Vec VZ = myAxes.Direction();
349   
350   switch (i/2) {
351     
352   case 0 :
353     D = myAxes.XDirection();
354     break;
355     
356   case 1 :
357     D = myAxes.YDirection();
358     break;
359     
360   case 2 :
361     D = myAxes.Direction();
362     break;
363     
364   };
365   Standard_Real X = 0., Y = 0., Z = 0.;
366   
367   switch (i) {
368     
369   case 0 :
370     // XMin
371     X = XMin;
372     Y = YMin;
373     Z = ZMin;
374     if ( X2Min != XMin ) D = gp_Dir((YMax-YMin)*VX+(XMin-X2Min)*VY);
375     break;
376     
377   case 1 :
378     // XMax
379     X = XMax;
380     Y = YMin;
381     Z = ZMin;
382     if ( X2Max != XMax )  D = gp_Dir((YMax-YMin)*VX+(XMax-X2Max)*VY);
383     break;
384     
385   case 2 :
386     // YMin
387     X = XMin;
388     Y = YMin;
389     Z = ZMin;
390     break;
391     
392   case 3 :
393     // YMax
394     X = XMin;
395     Y = YMax;
396     Z = ZMin;
397     break;
398     
399   case 4 :
400     // ZMin
401     X = XMin;
402     Y = YMin;
403     Z = ZMin;
404     if ( Z2Min != ZMin ) D = gp_Dir((YMax-YMin)*VZ+(ZMin-Z2Min)*VY);
405     break;
406     
407   case 5 :
408     // ZMax
409     X = XMin;
410     Y = YMin;
411     Z = ZMax;
412     if ( Z2Max != ZMax )  D = gp_Dir((YMax-YMin)*VZ+(ZMax-Z2Max)*VY);
413     break;
414     
415   };
416   
417   gp_Pnt P = myAxes.Location();
418   P.Translate(X*gp_Vec(myAxes.XDirection()));
419   P.Translate(Y*gp_Vec(myAxes.YDirection()));
420   P.Translate(Z*gp_Vec(myAxes.Direction ()));
421   gp_Pln plane(P,D);
422   return plane;
423 }
424
425 //=======================================================================
426 //function : Face
427 //purpose  : the face in one direction
428 //=======================================================================
429
430 const TopoDS_Face& BRepPrim_GWedge::Face 
431        (const BRepPrim_Direction d1)
432 {
433
434   Standard_Integer i = BRepPrim_Wedge_NumDir1(d1);
435
436   if (!FacesBuilt[i]) {
437     gp_Pln P = Plane(d1);
438     myBuilder.MakeFace(myFaces[i],P);
439     if (HasWire(d1)) myBuilder.AddFaceWire(myFaces[i],Wire(d1));
440     if ( i%2 == 0 ) myBuilder.ReverseFace(myFaces[i]);
441
442     // pcurves
443
444     BRepPrim_Direction dd1 = BRepPrim_ZMin, dd2 = BRepPrim_YMax, 
445     dd3 = BRepPrim_ZMax,dd4 = BRepPrim_YMin;
446
447     switch (i/2) {
448       
449     case 0 :
450       // XMin XMax
451       dd1 = BRepPrim_ZMin;
452       dd2 = BRepPrim_YMax;
453       dd3 = BRepPrim_ZMax;
454       dd4 = BRepPrim_YMin;
455       break;
456       
457     case 1 :
458       // YMin YMax
459       dd1 = BRepPrim_XMin;
460       dd2 = BRepPrim_ZMax;
461       dd3 = BRepPrim_XMax;
462       dd4 = BRepPrim_ZMin;
463       break;
464       
465     case 2 :
466       // ZMin ZMax
467       dd1 = BRepPrim_YMin;
468       dd2 = BRepPrim_XMax;
469       dd3 = BRepPrim_YMax;
470       dd4 = BRepPrim_XMin;
471       break;
472       
473     };
474
475     gp_Lin L;
476     gp_Dir DX = P.XAxis().Direction();
477     gp_Dir DY = P.YAxis().Direction();
478     Standard_Real U,V,DU,DV;
479     if (HasEdge(d1,dd4)) {
480       L = Line(d1,dd4);
481     ElSLib::Parameters(P,L.Location(),U,V);
482       DU = L.Direction() * DX;
483       DV = L.Direction() * DY;
484       myBuilder.SetPCurve(myEdges[BRepPrim_Wedge_NumDir2(d1,dd4)],
485                           myFaces[i],
486                           gp_Lin2d(gp_Pnt2d(U,V),gp_Dir2d(DU,DV)));
487     }
488     if (HasEdge(d1,dd3)) {
489       L = Line(d1,dd3);
490     ElSLib::Parameters(P,L.Location(),U,V);
491       DU = L.Direction() * DX;
492       DV = L.Direction() * DY;
493       myBuilder.SetPCurve(myEdges[BRepPrim_Wedge_NumDir2(d1,dd3)],
494                           myFaces[i],
495                           gp_Lin2d(gp_Pnt2d(U,V),gp_Dir2d(DU,DV)));
496     }
497
498     if (HasEdge(d1,dd2)) {
499       L = Line(d1,dd2);
500     ElSLib::Parameters(P,L.Location(),U,V);
501       DU = L.Direction() * DX;
502       DV = L.Direction() * DY;
503       myBuilder.SetPCurve(myEdges[BRepPrim_Wedge_NumDir2(d1,dd2)],
504                           myFaces[i],
505                           gp_Lin2d(gp_Pnt2d(U,V),gp_Dir2d(DU,DV)));
506     }
507
508     if (HasEdge(d1,dd1)) {
509       L = Line(d1,dd1);
510     ElSLib::Parameters(P,L.Location(),U,V);
511       DU = L.Direction() * DX;
512       DV = L.Direction() * DY;
513       myBuilder.SetPCurve(myEdges[BRepPrim_Wedge_NumDir2(d1,dd1)],
514                           myFaces[i],
515                           gp_Lin2d(gp_Pnt2d(U,V),gp_Dir2d(DU,DV)));
516     }
517
518    
519     myBuilder.CompleteFace(myFaces[i]);
520     FacesBuilt[i] = Standard_True;
521   }
522   
523   return myFaces[i];
524   
525 }
526
527 //=======================================================================
528 //function : HasWire
529 //purpose  : trivial
530 //=======================================================================
531
532 Standard_Boolean BRepPrim_GWedge::HasWire (const BRepPrim_Direction d1) const
533 {
534   Standard_Integer i = BRepPrim_Wedge_NumDir1(d1);
535
536   if (myInfinite[i]) return Standard_False;
537   BRepPrim_Direction dd1 = BRepPrim_XMin,dd2 = BRepPrim_YMax,dd3 = BRepPrim_XMax ,dd4 = BRepPrim_ZMin;
538
539   switch (i/2) {
540     
541   case 0 :
542     // XMin XMax
543     dd1 = BRepPrim_ZMin;
544     dd2 = BRepPrim_YMax;
545     dd3 = BRepPrim_ZMax;
546     dd4 = BRepPrim_YMin;
547     break;
548     
549   case 1 :
550     // YMin YMax
551     dd1 = BRepPrim_XMin;
552     dd2 = BRepPrim_ZMax;
553     dd3 = BRepPrim_XMax;
554     dd4 = BRepPrim_ZMin;
555     break;
556     
557   case 2 :
558     // ZMin ZMax
559     dd1 = BRepPrim_YMin;
560     dd2 = BRepPrim_XMax;
561     dd3 = BRepPrim_YMax;
562     dd4 = BRepPrim_XMin;
563     break;
564 #ifndef OCCT_DEBUG
565   default:
566     break;
567 #endif
568   };
569
570   return HasEdge(d1,dd1)||HasEdge(d1,dd2)||HasEdge(d1,dd3)||HasEdge(d1,dd4);
571
572 }
573
574 //=======================================================================
575 //function : Wire
576 //purpose  : trivial
577 //=======================================================================
578
579 const TopoDS_Wire& BRepPrim_GWedge::Wire
580        (const BRepPrim_Direction d1)
581 {
582   Standard_Integer i = BRepPrim_Wedge_NumDir1(d1);
583
584   BRepPrim_Direction dd1 = BRepPrim_XMin,dd2 = BRepPrim_YMax,dd3 = BRepPrim_XMax ,dd4 = BRepPrim_ZMin;
585
586   if (!WiresBuilt[i]) {
587
588     switch (i/2) {
589       
590     case 0 :
591       // XMin XMax
592       dd1 = BRepPrim_ZMin;
593       dd2 = BRepPrim_YMax;
594       dd3 = BRepPrim_ZMax;
595       dd4 = BRepPrim_YMin;
596       break;
597       
598     case 1 :
599       // YMin YMax
600       dd1 = BRepPrim_XMin;
601       dd2 = BRepPrim_ZMax;
602       dd3 = BRepPrim_XMax;
603       dd4 = BRepPrim_ZMin;
604       break;
605       
606     case 2 :
607       // ZMin ZMax
608       dd1 = BRepPrim_YMin;
609       dd2 = BRepPrim_XMax;
610       dd3 = BRepPrim_YMax;
611       dd4 = BRepPrim_XMin;
612       break;
613     default:
614       break;
615     };
616
617     myBuilder.MakeWire(myWires[i]);
618   
619     if (HasEdge(d1,dd4))
620       myBuilder.AddWireEdge(myWires[i],Edge(d1,dd4),Standard_False);
621     if (HasEdge(d1,dd3))
622       myBuilder.AddWireEdge(myWires[i],Edge(d1,dd3),Standard_False);
623     if (HasEdge(d1,dd2))
624       myBuilder.AddWireEdge(myWires[i],Edge(d1,dd2),Standard_True );
625     if (HasEdge(d1,dd1))
626       myBuilder.AddWireEdge(myWires[i],Edge(d1,dd1),Standard_True );
627    
628     myBuilder.CompleteWire(myWires[i]);
629     WiresBuilt[i] = Standard_True;
630   }
631    
632   return myWires[i];
633
634 }
635
636 //=======================================================================
637 //function : HasEdge
638 //purpose  : trivial
639 //=======================================================================
640
641 Standard_Boolean BRepPrim_GWedge::HasEdge (const BRepPrim_Direction d1,
642                                    const BRepPrim_Direction d2) const
643 {
644   Standard_Boolean state = !(myInfinite[BRepPrim_Wedge_NumDir1(d1)] ||
645                     myInfinite[BRepPrim_Wedge_NumDir1(d2)]);
646   Standard_Integer i = BRepPrim_Wedge_NumDir2(d1,d2);
647   if      ( i == 6 || i == 7 ) state = state && ( X2Max != X2Min );
648   else if ( i == 1 || i == 3 ) state = state && ( Z2Max != Z2Min );
649   return state;
650 }
651
652 //=======================================================================
653 //function : Line
654 //purpose  : trivial
655 //=======================================================================
656
657 gp_Lin BRepPrim_GWedge::Line
658   (const BRepPrim_Direction d1,
659    const BRepPrim_Direction d2)
660 {
661   if (!HasEdge(d1,d2)) throw Standard_DomainError();
662
663   Standard_Integer i = BRepPrim_Wedge_NumDir2(d1,d2);
664
665   Standard_Real X =0., Y =0., Z =0.;
666
667   gp_Dir D;
668   gp_Vec VX = myAxes.XDirection();
669   gp_Vec VY = myAxes.YDirection();
670   gp_Vec VZ = myAxes.Direction();
671
672   switch (i/4) {
673
674   case 0 :
675     D = myAxes.Direction();
676     break;
677
678   case 1 :
679     D = myAxes.XDirection();
680     break;
681
682   case 2 :
683     D = myAxes.YDirection();
684     break;
685
686   };
687
688   switch (i) {
689
690   case 0 :
691     // XMin YMin
692     X = XMin;
693     Y = YMin;
694     Z = ZMin;
695     break;
696
697   case 1 :
698     // XMin YMax
699     X = X2Min;
700     Y = YMax;
701     Z = Z2Min;
702     break;
703
704   case 2 :
705     // XMax YMin
706     X = XMax;
707     Y = YMin;
708     Z = ZMin;
709     break;
710
711   case 3 :
712     // XMax YMax
713     X = X2Max;
714     Y = YMax;
715     Z = Z2Min;
716     break;
717
718   case 4 :
719     // YMin ZMin
720     X = XMin;
721     Y = YMin;
722     Z = ZMin;
723     break;
724
725   case 5 :
726     // YMin ZMax
727     X = XMin;
728     Y = YMin;
729     Z = ZMax;
730     break;
731
732   case 6 :
733     // YMax ZMin
734     X = X2Min;
735     Y = YMax;
736     Z = Z2Min;
737     break;
738
739   case 7 :
740     // YMax ZMax
741     X = X2Min;
742     Y = YMax;
743     Z = Z2Max;
744     break;
745
746   case 8 :
747     // ZMin XMin
748     X = XMin;
749     Y = YMin;
750     Z = ZMin;
751     if ( (XMin != X2Min) || (ZMin != Z2Min) )
752     {
753       D = gp_Vec( (X2Min-XMin)*VX + (YMax-YMin)*VY + (Z2Min-ZMin)*VZ);
754     }
755     break;
756
757   case 9 :
758     // ZMax XMin
759     X = XMin;
760     Y = YMin;
761     Z = ZMax;
762     if ( (XMin != X2Min) || (ZMax != Z2Max) )
763     {
764       D = gp_Vec( (X2Min-XMin)*VX + (YMax-YMin)*VY + (Z2Max-ZMax)*VZ);
765     }
766     break;
767
768   case 10 :
769     // ZMin XMax
770     X = XMax;
771     Y = YMin;
772     Z = ZMin;
773     if ( (XMax != X2Max) || (ZMin != Z2Min) )
774     {
775       D = gp_Vec( (X2Max-XMax)*VX + (YMax-YMin)*VY + (Z2Min-ZMin)*VZ);
776     }
777     break;
778
779   case 11 :
780     // ZMax XMax
781     X = XMax;
782     Y = YMin;
783     Z = ZMax;
784     if ( (XMax != X2Max) || (ZMax != Z2Max) )
785     {
786       D = gp_Vec( (X2Max-XMax)*VX + (YMax-YMin)*VY + (Z2Max-ZMax)*VZ);
787     }
788     break;
789
790   }
791
792   gp_Pnt P = myAxes.Location();
793   P.Translate(X*gp_Vec(myAxes.XDirection()));
794   P.Translate(Y*gp_Vec(myAxes.YDirection()));
795   P.Translate(Z*gp_Vec(myAxes.Direction ()));
796   return gp_Lin(gp_Ax1(P,D));
797
798 }
799
800 //=======================================================================
801 //function : Edge
802 //purpose  : trivial
803 //=======================================================================
804
805 const TopoDS_Edge& BRepPrim_GWedge::Edge
806        (const BRepPrim_Direction d1,
807         const BRepPrim_Direction d2)
808 {
809   if (!HasEdge(d1,d2)) throw Standard_DomainError();
810
811   Standard_Integer i = BRepPrim_Wedge_NumDir2(d1,d2);
812
813   if (!EdgesBuilt[i]) {
814
815     BRepPrim_Direction dd1 = BRepPrim_XMin ,dd2 = BRepPrim_XMax;
816
817     switch (i/4) {
818     
819     case 0 :
820       dd1 = BRepPrim_ZMin;
821       dd2 = BRepPrim_ZMax;
822       break;
823     
824     case 1 :
825       dd1 = BRepPrim_XMin;
826       dd2 = BRepPrim_XMax;
827       break;
828     
829     case 2 :
830       dd1 = BRepPrim_YMin;
831       dd2 = BRepPrim_YMax;
832       break;
833
834     default:
835       break;
836     };
837     
838     gp_Lin L = Line(d1,d2);
839     myBuilder.MakeEdge(myEdges[i],L);
840     
841     if (HasVertex(d1,d2,dd2)) {
842       myBuilder.AddEdgeVertex(myEdges[i],Vertex(d1,d2,dd2),
843                               ElCLib::Parameter(L,Point(d1,d2,dd2)),
844                               Standard_False);
845     }
846     if (HasVertex(d1,d2,dd1)) {
847       myBuilder.AddEdgeVertex(myEdges[i],Vertex(d1,d2,dd1),
848                               ElCLib::Parameter(L,Point(d1,d2,dd1)),
849                               Standard_True );
850     }
851     
852     if ( Z2Max == Z2Min ) {
853       if ( i == 6 ) {
854         myEdges[7]    = myEdges[6];
855         EdgesBuilt[7] = Standard_True;
856       }
857       else if ( i == 7 ) {
858         myEdges[6]    = myEdges[7];
859         EdgesBuilt[6] = Standard_True;
860       }
861     }
862     if ( X2Max == X2Min ) {
863       if ( i == 1 ) {
864         myEdges[3]    = myEdges[1];
865         EdgesBuilt[3] = Standard_True;
866       }
867       else if ( i == 3 ) {
868         myEdges[1]    = myEdges[3];
869         EdgesBuilt[1] = Standard_True;
870       }
871     }
872
873     myBuilder.CompleteEdge(myEdges[i]);
874     EdgesBuilt[i] = Standard_True;
875   }
876
877   return myEdges[i];
878
879 }
880
881 //=======================================================================
882 //function : HasVertex
883 //purpose  : trivial
884 //=======================================================================
885
886 Standard_Boolean BRepPrim_GWedge::HasVertex
887   (const BRepPrim_Direction d1,
888    const BRepPrim_Direction d2,
889    const BRepPrim_Direction d3) const
890 { return !(myInfinite[BRepPrim_Wedge_NumDir1(d1)] ||
891            myInfinite[BRepPrim_Wedge_NumDir1(d2)] ||
892            myInfinite[BRepPrim_Wedge_NumDir1(d3)]); }
893
894 //=======================================================================
895 //function : Point
896 //purpose  : trivial
897 //=======================================================================
898
899 gp_Pnt  BRepPrim_GWedge::Point
900   (const BRepPrim_Direction d1,
901    const BRepPrim_Direction d2,
902    const BRepPrim_Direction d3)
903 {
904   if (!HasVertex(d1,d2,d3)) throw Standard_DomainError();
905
906   Standard_Integer i = BRepPrim_Wedge_NumDir3(d1,d2,d3);
907
908   Standard_Real X =0., Y =0., Z =0.;
909
910   switch (i) {
911     
912   case 0 :
913     X = XMin;
914     Y = YMin;
915     Z = ZMin;
916     break;
917     
918   case 1 :
919     X = XMin;
920     Y = YMin;
921     Z = ZMax;
922     break;
923     
924   case 2 :
925     X = X2Min;
926     Y = YMax;
927     Z = Z2Min;
928     break;
929     
930   case 3 :
931     X = X2Min;
932     Y = YMax;
933     Z = Z2Max;
934     break;
935     
936   case 4 :
937     X = XMax;
938     Y = YMin;
939     Z = ZMin;
940     break;
941     
942   case 5 :
943     X = XMax;
944     Y = YMin;
945     Z = ZMax;
946     break;
947     
948   case 6 :
949     X = X2Max;
950     Y = YMax;
951     Z = Z2Min;
952     break;
953
954   case 7 :
955     X = X2Max;
956     Y = YMax;
957     Z = Z2Max;
958     break;
959     
960   };
961
962   gp_Pnt P = myAxes.Location();
963   P.Translate(X*gp_Vec(myAxes.XDirection()));
964   P.Translate(Y*gp_Vec(myAxes.YDirection()));
965   P.Translate(Z*gp_Vec(myAxes.Direction ()));
966   return P;
967 }
968
969 //=======================================================================
970 //function : Vertex
971 //purpose  : trivial
972 //=======================================================================
973
974 const TopoDS_Vertex& BRepPrim_GWedge::Vertex 
975        (const BRepPrim_Direction d1,
976         const BRepPrim_Direction d2,
977         const BRepPrim_Direction d3)
978 {
979   if (!HasVertex(d1,d2,d3)) throw Standard_DomainError();
980
981   Standard_Integer i = BRepPrim_Wedge_NumDir3(d1,d2,d3);
982
983   if (!VerticesBuilt[i]) {
984
985     myBuilder.MakeVertex(myVertices[i],Point(d1,d2,d3));
986
987     if ( Z2Max == Z2Min ) {
988       if      ( i == 2 || i == 6 ) {
989         myVertices[3] = myVertices[2];
990         myVertices[7] = myVertices[6];
991         VerticesBuilt[3] = Standard_True;
992         VerticesBuilt[7] = Standard_True;
993       }
994       else if ( i == 3 || i == 7 ) {
995         myVertices[2] = myVertices[3];
996         myVertices[6] = myVertices[7];
997         VerticesBuilt[2] = Standard_True;
998         VerticesBuilt[6] = Standard_True;
999       }
1000     }
1001     if ( X2Max == X2Min ) {
1002       if      ( i == 2 || i == 3 ) {
1003         myVertices[6] = myVertices[2];
1004         myVertices[7] = myVertices[3];
1005         VerticesBuilt[6] = Standard_True;
1006         VerticesBuilt[7] = Standard_True;
1007       }
1008       else if ( i == 6 || i == 7 ) {
1009         myVertices[2] = myVertices[6];
1010         myVertices[3] = myVertices[7];
1011         VerticesBuilt[2] = Standard_True;
1012         VerticesBuilt[3] = Standard_True;
1013       }
1014     }
1015
1016     VerticesBuilt[i] = Standard_True;
1017   }
1018
1019   return myVertices[i];
1020
1021 }
1022