\feff0025129: Visualization - add interactive object for Points Cloud objects
[occt.git] / src / StdPrs / StdPrs_WFDeflectionRestrictedFace.cxx
1 // Created on: 1995-08-07
2 // Created by: Modelistation
3 // Copyright (c) 1995-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 #include <StdPrs_WFDeflectionRestrictedFace.ixx>
18
19 #include <Hatch_Hatcher.hxx>
20 #include <Graphic3d_ArrayOfPolylines.hxx>
21 #include <Graphic3d_AspectLine3d.hxx>
22 #include <Graphic3d_Group.hxx>
23 #include <gp_Pnt.hxx>
24 #include <gp_Pnt2d.hxx>
25 #include <Prs3d_IsoAspect.hxx>
26 #include <Adaptor2d_Curve2d.hxx>
27 #include <GCPnts_QuasiUniformDeflection.hxx>
28 #include <Adaptor3d_IsoCurve.hxx>
29 #include <StdPrs_DeflectionCurve.hxx>
30 #include <StdPrs_ToolRFace.hxx>
31 #include <Bnd_Box2d.hxx>
32 #include <BndLib_Add2dCurve.hxx>
33 #include <Precision.hxx>
34 #include <GeomAdaptor_Curve.hxx>
35 #include <Geom_Curve.hxx>
36 #include <GeomAbs_SurfaceType.hxx>
37 #include <Geom_Surface.hxx>
38 #include <TColgp_SequenceOfPnt2d.hxx>
39
40
41
42
43 #ifdef DEB_MESH
44 #include <OSD_Chronometer.hxx>
45 extern OSD_Chronometer FFaceTimer1,FFaceTimer2,FFaceTimer3,FFaceTimer4;
46 #endif
47
48
49 //==================================================================
50 // function: FindLimits
51 // purpose:
52 //==================================================================
53 static void FindLimits(const Adaptor3d_Curve& aCurve,
54                        const Standard_Real  aLimit,
55                        Standard_Real&       First,
56                        Standard_Real&       Last)
57 {
58   First = Max(aCurve.FirstParameter(), First);
59   Last  = Min(aCurve.LastParameter(), Last);
60   Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
61   Standard_Boolean lastInf  = Precision::IsPositiveInfinite(Last);
62
63   if (firstInf || lastInf) {
64     gp_Pnt P1,P2;
65     Standard_Real delta = 1;
66     if (firstInf && lastInf) {
67       do {
68         delta *= 2;
69         First = - delta;
70         Last  =   delta;
71         aCurve.D0(First,P1);
72         aCurve.D0(Last,P2);
73       } while (P1.Distance(P2) < aLimit);
74     }
75     else if (firstInf) {
76       aCurve.D0(Last,P2);
77       do {
78         delta *= 2;
79         First = Last - delta;
80         aCurve.D0(First,P1);
81       } while (P1.Distance(P2) < aLimit);
82     }
83     else if (lastInf) {
84       aCurve.D0(First,P1);
85       do {
86         delta *= 2;
87         Last = First + delta;
88         aCurve.D0(Last,P2);
89       } while (P1.Distance(P2) < aLimit);
90     }
91   }    
92
93 }
94
95
96 //=========================================================================
97 // function: Add
98 // purpose
99 //=========================================================================
100 void StdPrs_WFDeflectionRestrictedFace::Add
101   (const Handle (Prs3d_Presentation)& aPresentation,
102    const Handle(BRepAdaptor_HSurface)& aFace,
103    const Standard_Boolean DrawUIso,
104    const Standard_Boolean DrawVIso,
105    const Quantity_Length Deflection,
106    const Standard_Integer NBUiso,
107    const Standard_Integer NBViso,
108    const Handle(Prs3d_Drawer)& aDrawer,
109    Prs3d_NListOfSequenceOfPnt& Curves) {
110
111 #ifdef DEB_MESH
112   FFaceTimer1.Start();
113 #endif
114
115   StdPrs_ToolRFace ToolRst (aFace);
116   Standard_Real UF, UL, VF, VL;
117   UF = aFace->FirstUParameter();
118   UL = aFace->LastUParameter();
119   VF = aFace->FirstVParameter();
120   VL = aFace->LastVParameter();
121
122   Standard_Real aLimit = aDrawer->MaximalParameterValue();
123
124   // compute bounds of the restriction
125   Standard_Real UMin,UMax,VMin,VMax;
126   //Standard_Real u,v,step;
127   Standard_Integer i;//,nbPoints = 10;
128
129   UMin = Max(UF, -aLimit);
130   UMax = Min(UL, aLimit);
131   VMin = Max(VF, -aLimit);
132   VMax = Min(VL, aLimit);
133
134
135   // update min max for the hatcher.
136   gp_Pnt2d P1,P2;
137   Standard_Real U1, U2;
138   gp_Pnt dummypnt;
139   Standard_Real ddefle= Max(UMax-UMin, VMax-VMin) * aDrawer->DeviationCoefficient();
140   TColgp_SequenceOfPnt2d tabP;
141   Standard_Real aHatchingTol = 1.e100;
142
143   UMin = VMin = 1.e100;
144   UMax = VMax = -1.e100;
145   
146   for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
147     TopAbs_Orientation Orient = ToolRst.Orientation();
148     if ( Orient == TopAbs_FORWARD || Orient == TopAbs_REVERSED ) {
149       Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
150       if (TheRCurve->GetType() != GeomAbs_Line) {
151         GCPnts_QuasiUniformDeflection UDP(*TheRCurve, ddefle);
152         if (UDP.IsDone()) {
153           Standard_Integer NumberOfPoints = UDP.NbPoints();
154           if ( NumberOfPoints >= 2 ) {
155             dummypnt = UDP.Value(1);
156             P2.SetCoord(dummypnt.X(), dummypnt.Y());
157             UMin = Min(P2.X(), UMin);
158             UMax = Max(P2.X(), UMax);
159             VMin = Min(P2.Y(), VMin);
160             VMax = Max(P2.Y(), VMax);
161             for (i = 2; i <= NumberOfPoints; i++) {
162               P1 = P2;
163               dummypnt = UDP.Value(i);
164               P2.SetCoord(dummypnt.X(), dummypnt.Y());
165               UMin = Min(P2.X(), UMin);
166               UMax = Max(P2.X(), UMax);
167               VMin = Min(P2.Y(), VMin);
168               VMax = Max(P2.Y(), VMax);
169               aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);
170
171               if(Orient == TopAbs_FORWARD ) {
172                 //isobuild.Trim(P1,P2);
173                 tabP.Append(P1);
174                 tabP.Append(P2);
175               }
176               else {
177                 //isobuild.Trim(P2,P1);
178                 tabP.Append(P2);
179                 tabP.Append(P1);
180               }
181             }
182           }
183         }
184         else {
185           cout << "Cannot evaluate curve on surface"<<endl;
186         }
187       }
188       else {
189         U1 = TheRCurve->FirstParameter();
190         U2 = TheRCurve->LastParameter();
191         // MSV 17.08.06 OCC13144: U2 occured less than U1, to overcome it
192         // ensure that distance U2-U1 is not greater than aLimit*2,
193         // if greater then choose an origin and use aLimit to define
194         // U1 and U2 anew
195         Standard_Real aOrigin = 0.;
196         if (!Precision::IsNegativeInfinite(U1) || !Precision::IsPositiveInfinite(U2)) {
197           if (Precision::IsNegativeInfinite(U1))
198             aOrigin = U2 - aLimit;
199           else if (Precision::IsPositiveInfinite(U2))
200             aOrigin = U1 + aLimit;
201           else
202             aOrigin = (U1 + U2) * 0.5;
203         }
204         U1 = Max(aOrigin - aLimit, U1);
205         U2 = Min(aOrigin + aLimit, U2);
206         P1 = TheRCurve->Value(U1);
207         P2 = TheRCurve->Value(U2);
208         UMin = Min(P1.X(), UMin);
209         UMax = Max(P1.X(), UMax);
210         VMin = Min(P1.Y(), VMin);
211         VMax = Max(P1.Y(), VMax);
212         UMin = Min(P2.X(), UMin);
213         UMax = Max(P2.X(), UMax);
214         VMin = Min(P2.Y(), VMin);
215         VMax = Max(P2.Y(), VMax);
216         aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);
217
218         if(Orient == TopAbs_FORWARD ) {
219          // isobuild.Trim(P1,P2);
220           tabP.Append(P1);
221           tabP.Append(P2);
222         }
223         else {
224           //isobuild.Trim(P2,P1);
225           tabP.Append(P2);
226           tabP.Append(P1);
227         }
228       }
229     }
230   }
231
232
233 #ifdef DEB_MESH
234   FFaceTimer1.Stop();
235
236   FFaceTimer2.Start();
237 #endif
238
239   // Compute the hatching tolerance.
240   aHatchingTol *= 0.1;
241   aHatchingTol = Max(Precision::Confusion(), aHatchingTol);
242   aHatchingTol = Min(1.e-5, aHatchingTol);
243
244   // load the isos
245   Hatch_Hatcher isobuild(aHatchingTol, ToolRst.IsOriented());
246   Standard_Boolean UClosed = aFace->IsUClosed();
247   Standard_Boolean VClosed = aFace->IsVClosed();
248
249   if ( ! UClosed ) {
250     UMin = UMin + ( UMax - UMin) /1000.;
251     UMax = UMax - ( UMax - UMin) /1000.; 
252   }
253
254   if ( ! VClosed ) {
255     VMin = VMin + ( VMax - VMin) /1000.;
256     VMax = VMax - ( VMax - VMin) /1000.; 
257   }
258
259   if (DrawUIso){
260     if (NBUiso > 0) {
261       UClosed = Standard_False; // En attendant un hatcher de course.
262       Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
263       for (i=1; i<=NBUiso;i++){
264         isobuild.AddXLine(UMin+du*i);
265       }
266     }
267   }
268   if (DrawVIso){
269     if ( NBViso > 0) {
270       VClosed = Standard_False;
271       Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
272       for (i=1; i<=NBViso;i++){
273         isobuild.AddYLine(VMin+dv*i);
274       }
275     }
276   }
277
278 #ifdef DEB_MESH
279   FFaceTimer2.Stop();
280   FFaceTimer3.Start();
281 #endif
282
283   
284   Standard_Integer ll = tabP.Length();
285   for (i = 1; i <= ll; i+=2) {
286     isobuild.Trim(tabP(i),tabP(i+1));
287   }
288
289
290 #ifdef DEB_MESH  
291   FFaceTimer3.Stop();
292   FFaceTimer4.Start();
293 #endif
294
295   // draw the isos
296
297   Adaptor3d_IsoCurve anIso;
298   anIso.Load(aFace);
299   Handle(Geom_Curve) BC;
300   const BRepAdaptor_Surface& BS = *(BRepAdaptor_Surface*)&(aFace->Surface());
301   GeomAbs_SurfaceType thetype = aFace->GetType();
302
303   Standard_Integer NumberOfLines = isobuild.NbLines();
304   Handle(Geom_Surface) GB;
305   if (thetype == GeomAbs_BezierSurface) {
306     GB = BS.Bezier();
307   }
308   else if (thetype == GeomAbs_BSplineSurface){
309     GB = BS.BSpline();
310   }
311
312   Standard_Real anAngle = aDrawer->DeviationAngle();
313
314   for (i = 1; i <= NumberOfLines; i++) {
315     Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
316     Standard_Real Coord = isobuild.Coordinate(i);
317     for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
318       Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);
319
320
321       if (!GB.IsNull()) {
322         if (isobuild.IsXLine(i))
323           BC = GB->UIso(Coord);
324         else 
325           BC = GB->VIso(Coord);
326         GeomAdaptor_Curve GC(BC);
327         FindLimits(GC, aLimit,b1, b2);
328         if (b2-b1>Precision::Confusion()) {
329           Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
330           StdPrs_DeflectionCurve::Add (aPresentation, GC, b1, b2, Deflection, 
331                                        Points->ChangeSequence(), anAngle, Standard_False);
332           Curves.Append(Points);
333         }
334       }
335       else {
336         if (isobuild.IsXLine(i))
337           anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
338         else
339           anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
340         FindLimits(anIso, aLimit,b1, b2);
341         if (b2-b1>Precision::Confusion()) {
342           Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
343           StdPrs_DeflectionCurve::Add (aPresentation, anIso, b1, b2, Deflection, 
344                                        Points->ChangeSequence(), anAngle, Standard_False);
345           Curves.Append(Points);
346         }
347       }
348     }
349   }
350 #ifdef DEB_MESH
351   FFaceTimer4.Stop();
352 #endif
353 }
354
355
356 //=========================================================================
357 // function: Match
358 // purpose
359 //=========================================================================
360 Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
361   (const Quantity_Length X,
362    const Quantity_Length Y,
363    const Quantity_Length Z,
364    const Quantity_Length aDistance,
365    const Handle(BRepAdaptor_HSurface)& aFace,
366    const Handle(Prs3d_Drawer)& aDrawer,
367    const Standard_Boolean DrawUIso,
368    const Standard_Boolean DrawVIso,
369    const Quantity_Length Deflection,
370    const Standard_Integer NBUiso,
371    const Standard_Integer NBViso)
372 {
373
374    StdPrs_ToolRFace ToolRst (aFace);
375    const Standard_Real aLimit = aDrawer->MaximalParameterValue();
376
377   // compute bounds of the restriction
378   Standard_Real UMin,UMax,VMin,VMax;
379   Standard_Real u,v,step;
380   Standard_Integer i,nbPoints = 10;
381   UMin = VMin = RealLast();
382   UMax = VMax = RealFirst();
383   
384   for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
385     Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
386     u = TheRCurve->FirstParameter();
387     v = TheRCurve->LastParameter();
388     step = ( v - u) / nbPoints;
389     for (i = 0; i <= nbPoints; i++) {
390       gp_Pnt2d P = TheRCurve->Value(u);
391       if (P.X() < UMin) UMin = P.X();
392       if (P.X() > UMax) UMax = P.X();
393       if (P.Y() < VMin) VMin = P.Y();
394       if (P.Y() > VMax) VMax = P.Y();
395       u += step;
396     }
397   }
398   
399   // load the isos
400   Hatch_Hatcher isobuild(1.e-5,ToolRst.IsOriented());
401   Standard_Boolean UClosed = aFace->IsUClosed();
402   Standard_Boolean VClosed = aFace->IsVClosed();
403
404   if ( ! UClosed ) {
405     UMin = UMin + ( UMax - UMin) /1000.;
406     UMax = UMax - ( UMax - UMin) /1000.; 
407   }
408
409   if ( ! VClosed ) {
410     VMin = VMin + ( VMax - VMin) /1000.;
411     VMax = VMax - ( VMax - VMin) /1000.; 
412   }
413
414   if (DrawUIso){
415     if (NBUiso > 0) {
416       UClosed = Standard_False; // En attendant un hatcher de course.
417       Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
418       for (i=1; i<=NBUiso;i++){
419         isobuild.AddXLine(UMin+du*i);
420       }
421     }
422   }
423   if (DrawVIso){
424     if ( NBViso > 0) {
425       VClosed = Standard_False;
426       Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
427       for (i=1; i<=NBViso;i++){
428         isobuild.AddYLine(VMin+dv*i);
429       }
430     }
431   }
432
433   // trim the isos
434   gp_Pnt2d P1,P2;
435   gp_Pnt dummypnt;
436   for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
437     TopAbs_Orientation Orient = ToolRst.Orientation();
438     if ( Orient == TopAbs_FORWARD || Orient == TopAbs_REVERSED ) {
439       Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
440       GCPnts_QuasiUniformDeflection UDP(*TheRCurve, Deflection);
441       if (UDP.IsDone()) {
442         Standard_Integer NumberOfPoints = UDP.NbPoints();
443         if ( NumberOfPoints >= 2 ) {
444           dummypnt = UDP.Value(1);
445           P2.SetCoord(dummypnt.X(), dummypnt.Y());
446           for (i = 2; i <= NumberOfPoints; i++) {
447             P1 = P2;
448             dummypnt = UDP.Value(i);
449             P2.SetCoord(dummypnt.X(), dummypnt.Y());
450             if(Orient == TopAbs_FORWARD )
451               isobuild.Trim(P1,P2);
452             else
453               isobuild.Trim(P2,P1);
454           }
455         }
456       }
457       else {
458         cout << "Cannot evaluate curve on surface"<<endl;
459       }
460     }
461   }
462   
463   // draw the isos
464
465   Adaptor3d_IsoCurve anIso;
466   anIso.Load(aFace);
467   Standard_Integer NumberOfLines = isobuild.NbLines();
468   Standard_Real anAngle = aDrawer->DeviationAngle();
469
470   for (i = 1; i <= NumberOfLines; i++) {
471     Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
472     Standard_Real Coord = isobuild.Coordinate(i);
473     for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
474       Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);
475
476       b1 = b1 == RealFirst() ? - aLimit : b1;
477       b2 = b2 == RealLast()  ?   aLimit : b2;
478
479       if (isobuild.IsXLine(i))
480         anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
481       else
482         anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
483     
484       if (StdPrs_DeflectionCurve::Match(X,Y,Z,aDistance,anIso, b1, b2, Deflection, anAngle))
485           return Standard_True;
486     }
487   }
488   return Standard_False;
489 }
490
491
492 //=========================================================================
493 // function: Add
494 // purpose
495 //=========================================================================
496 void StdPrs_WFDeflectionRestrictedFace::Add
497   (const Handle (Prs3d_Presentation)& aPresentation,
498    const Handle(BRepAdaptor_HSurface)& aFace,
499    const Handle (Prs3d_Drawer)& aDrawer)
500 {
501   Prs3d_NListOfSequenceOfPnt Curves;
502   StdPrs_WFDeflectionRestrictedFace::Add (aPresentation,
503                                           aFace,
504                                           Standard_True,
505                                           Standard_True,
506                                           aDrawer->MaximalChordialDeviation(),
507                                           aDrawer->UIsoAspect()->Number(),
508                                           aDrawer->VIsoAspect()->Number(),
509                                           aDrawer,
510                                           Curves);
511 }
512
513
514 //=========================================================================
515 // function: AddUIso
516 // purpose
517 //=========================================================================
518 void StdPrs_WFDeflectionRestrictedFace::AddUIso
519   (const Handle (Prs3d_Presentation)& aPresentation,
520    const Handle(BRepAdaptor_HSurface)& aFace,
521    const Handle (Prs3d_Drawer)& aDrawer)
522 {
523   Prs3d_NListOfSequenceOfPnt Curves;
524   StdPrs_WFDeflectionRestrictedFace::Add ( 
525                       aPresentation,
526                       aFace,
527                       Standard_True,
528                       Standard_False,
529                       aDrawer->MaximalChordialDeviation(),
530                       aDrawer->UIsoAspect()->Number(),
531                       aDrawer->VIsoAspect()->Number(),
532                       aDrawer,
533                       Curves);
534 }
535
536
537 //=========================================================================
538 // function: AddVIso
539 // purpose
540 //=========================================================================
541 void StdPrs_WFDeflectionRestrictedFace::AddVIso
542   (const Handle (Prs3d_Presentation)& aPresentation,
543    const Handle(BRepAdaptor_HSurface)& aFace,
544    const Handle (Prs3d_Drawer)& aDrawer)
545 {
546   Prs3d_NListOfSequenceOfPnt Curves;
547   StdPrs_WFDeflectionRestrictedFace::Add ( 
548                       aPresentation,
549                       aFace,
550                       Standard_False,
551                       Standard_True,
552                       aDrawer->MaximalChordialDeviation(),
553                       aDrawer->UIsoAspect()->Number(),
554                       aDrawer->VIsoAspect()->Number(),
555                       aDrawer,
556                       Curves);
557 }
558
559
560 //=========================================================================
561 // function: Match
562 // purpose
563 //=========================================================================
564 Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
565   (const Quantity_Length X,
566    const Quantity_Length Y,
567    const Quantity_Length Z,
568    const Quantity_Length aDistance,
569    const Handle(BRepAdaptor_HSurface)& aFace,
570    const Handle (Prs3d_Drawer)& aDrawer)
571 {
572   return StdPrs_WFDeflectionRestrictedFace::Match (  
573                       X,Y,Z,aDistance,
574                       aFace,
575                       aDrawer,
576                       Standard_True,
577                       Standard_True,
578                       aDrawer->MaximalChordialDeviation(),
579                       aDrawer->UIsoAspect()->Number(),
580                       aDrawer->VIsoAspect()->Number());
581 }
582
583
584 //=========================================================================
585 // function: MatchUIso
586 // purpose
587 //=========================================================================
588 Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchUIso
589   (const Quantity_Length X,
590    const Quantity_Length Y,
591    const Quantity_Length Z,
592    const Quantity_Length aDistance,
593    const Handle(BRepAdaptor_HSurface)& aFace,
594    const Handle (Prs3d_Drawer)& aDrawer)
595 {
596   return StdPrs_WFDeflectionRestrictedFace::Match ( 
597                       X,Y,Z,aDistance,
598                       aFace,
599                       aDrawer,
600                       Standard_True,
601                       Standard_False,
602                       aDrawer->MaximalChordialDeviation(),
603                       aDrawer->UIsoAspect()->Number(),
604                       aDrawer->VIsoAspect()->Number());
605 }
606
607
608 //=========================================================================
609 // function: MatchVIso
610 // purpose
611 //=========================================================================
612 Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchVIso
613   (const Quantity_Length X,
614    const Quantity_Length Y,
615    const Quantity_Length Z,
616    const Quantity_Length aDistance,
617    const Handle(BRepAdaptor_HSurface)& aFace,
618    const Handle (Prs3d_Drawer)& aDrawer)
619 {
620   return StdPrs_WFDeflectionRestrictedFace::Match ( 
621                       X,Y,Z,aDistance,
622                       aFace,
623                       aDrawer,
624                       Standard_False,
625                       Standard_True,
626                       aDrawer->MaximalChordialDeviation(),
627                       aDrawer->UIsoAspect()->Number(),
628                       aDrawer->VIsoAspect()->Number());
629 }
630
631 namespace
632 {
633   static const Standard_Integer THE_INDICES[][3] =
634   { { 0, 0, 0 }, { 1, 0, 0 }, { 1, 0, 1 }, { 0, 0, 1 },
635     { 0, 1, 1 }, { 1, 1, 1 }, { 1, 1, 0 }, { 0, 1, 0 },
636     { 0, 0, 0 }, { 0, 0, 1 }, { 1, 0, 1 }, { 1, 1, 1 },
637     { 0, 1, 1 }, { 0, 1, 0 }, { 1, 1, 0 }, { 1, 0, 0 } };
638 }
639
640 //=======================================================================
641 //function : AddBox
642 //purpose  :
643 //=======================================================================
644 void StdPrs_WFDeflectionRestrictedFace::AddBox (const Handle(Prs3d_Presentation)& thePrs,
645                                                 const Bnd_Box&                    theBndBox,
646                                                 const Handle(Prs3d_Drawer)&       theDrawer)
647 {
648   if (theBndBox.IsVoid())
649   {
650     return;
651   }
652
653   Standard_Real X[2], Y[2], Z[2];
654   theBndBox.Get (X[0], Y[0], Z[0], X[1], Y[1], Z[1]);
655
656   Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (thePrs);
657   Quantity_Color    aColor;
658   Aspect_TypeOfLine aDummyLineType;
659   Standard_Real     aWidth = 1.0;
660   theDrawer->LineAspect()->Aspect()->Values (aColor, aDummyLineType, aWidth);
661
662   aGroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (aColor, Aspect_TOL_DOTDASH, aWidth));
663
664   Handle(Graphic3d_ArrayOfPolylines) aPolyline = new Graphic3d_ArrayOfPolylines(16);
665   for(Standard_Integer aVertIter = 0; aVertIter < 16; ++aVertIter)
666   {
667     aPolyline->AddVertex (X[THE_INDICES[aVertIter][0]],
668                           Y[THE_INDICES[aVertIter][1]],
669                           Z[THE_INDICES[aVertIter][2]]);
670   }
671   aGroup->AddPrimitiveArray (aPolyline);
672 }