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