a5d3ed2013e41663443c78fe0f705285845f6185
[occt.git] / src / AIS / AIS.cxx
1 // Created on: 1996-12-11
2 // Created by: Robert COUBLANC
3 // Copyright (c) 1996-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 <AIS.ixx>
18
19 #include <Adaptor3d_HCurve.hxx>
20 #include <Adaptor3d_HSurface.hxx>
21
22 #include <BRepBuilderAPI_MakeEdge.hxx>
23 #include <BRepBuilderAPI_MakeVertex.hxx>
24 #include <BRepAdaptor_Curve.hxx>
25 #include <BRepAdaptor_HSurface.hxx>
26 #include <BRepAdaptor_Surface.hxx>
27 #include <BRepTopAdaptor_FClass2d.hxx>
28 #include <BRep_Tool.hxx>
29 #include <BRepTools.hxx>
30 #include <Bnd_Box.hxx>
31
32 #include <ElCLib.hxx>
33 #include <ElSLib.hxx>
34
35 #include <GccEnt_QualifiedLin.hxx>
36 #include <gce_MakeDir.hxx>
37 #include <gce_MakeLin.hxx>
38 #include <Geom2d_Circle.hxx>
39 #include <GeomAPI_ExtremaCurveCurve.hxx>
40 #include <GeomAPI_IntSS.hxx>
41 #include <GeomAPI_ProjectPointOnCurve.hxx>
42 #include <GeomAPI_ProjectPointOnSurf.hxx>
43 #include <GeomLib.hxx>
44 #include <GeomProjLib.hxx>
45 #include <GeomProjLib.hxx>
46 #include <Geom_CartesianPoint.hxx>
47 #include <Geom_Circle.hxx>
48 #include <Geom_ConicalSurface.hxx>
49 #include <Geom_Curve.hxx>
50 #include <Geom_CylindricalSurface.hxx>
51 #include <Geom_Ellipse.hxx>
52 #include <Geom_Line.hxx>
53 #include <Geom_OffsetSurface.hxx>
54 #include <Geom_Plane.hxx>
55 #include <Geom_SphericalSurface.hxx>
56 #include <Geom_SurfaceOfLinearExtrusion.hxx>
57 #include <Geom_SurfaceOfRevolution.hxx>
58 #include <Geom_ToroidalSurface.hxx>
59 #include <Geom_TrimmedCurve.hxx>
60 #include <gp_Ax1.hxx>
61 #include <gp_Ax3.hxx>
62 #include <gp_Dir.hxx>
63 #include <gp_Elips.hxx>
64 #include <gp_Lin.hxx>
65 #include <gp_Pln.hxx>
66 #include <gp_Pnt.hxx>
67 #include <gp_Vec.hxx>
68 #include <gp_XYZ.hxx>
69 #include <Precision.hxx>
70 #include <Prs3d_LineAspect.hxx>
71 #include <Prs3d_PointAspect.hxx>
72 #include <StdPrs_Point.hxx>
73 #include <StdPrs_WFDeflectionShape.hxx>
74 #include <TColStd_Array1OfReal.hxx>
75 #include <TColStd_Array2OfReal.hxx>
76 #include <TopExp.hxx>
77 #include <TopExp_Explorer.hxx>
78 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
79 #include <TopoDS.hxx>
80 #include <Geom_Surface.hxx>
81
82 const Standard_Real SquareTolerance = Precision::SquareConfusion();
83
84 //=======================================================================
85 //function : Nearest
86 //purpose  :
87 //=======================================================================
88 gp_Pnt AIS::Nearest(const TopoDS_Shape& ashape, const gp_Pnt& apoint)
89 {
90   Standard_Real dist2 = RealLast();
91   Standard_Real curdist2;
92   gp_Pnt result(0.0,0.0,0.0);
93   gp_Pnt curpnt(0.0,0.0,0.0);
94   TopExp_Explorer explo(ashape,TopAbs_VERTEX);
95   while (explo.More())
96     {
97       curpnt = BRep_Tool::Pnt(TopoDS::Vertex(explo.Current()));
98       curdist2 = apoint.SquareDistance(curpnt);
99       if (curdist2 < dist2)
100         {
101           result = curpnt;
102           dist2 = curdist2;
103         }
104       explo.Next();
105     }
106   return result;
107 }
108
109 //=======================================================================
110 //function : Nearest
111 //purpose  : For <thePoint> finds the nearest point on <theLine>.
112 //=======================================================================
113 gp_Pnt AIS::Nearest (const gp_Lin& theLine, const gp_Pnt& thePoint)
114 {
115   Handle(Geom_Line) aLine = new Geom_Line (theLine);
116
117   GeomAPI_ProjectPointOnCurve aPointProj (thePoint, aLine);
118   return aPointProj.Point (1);
119 }
120
121 //=======================================================================
122 //function : Nearest
123 //purpose  : For the given point finds nearest point on the curve,
124 //           return TRUE if found point is belongs to curve
125 //              and FALSE otherwise.
126 //=======================================================================
127 Standard_Boolean AIS::Nearest (const Handle(Geom_Curve)& theCurve,
128                                const gp_Pnt& thePoint,
129                                const gp_Pnt& theFirstPoint,
130                                const gp_Pnt& theLastPoint,
131                                gp_Pnt& theNearestPoint)
132 {
133   GeomAPI_ProjectPointOnCurve aPointProj (thePoint, theCurve);
134   theNearestPoint = theCurve->Value (aPointProj.LowerDistanceParameter());
135
136   Standard_Real aLength = theFirstPoint.Distance (theLastPoint);
137
138   if (theNearestPoint.Distance (theFirstPoint) > aLength
139       || theNearestPoint.Distance (theLastPoint) >aLength)
140   {
141     return Standard_False;
142   }
143
144   return Standard_True;
145 }
146
147 //=======================================================================
148 //function : Farest
149 //purpose  :
150 //=======================================================================
151 gp_Pnt AIS::Farest( const TopoDS_Shape& aShape, const gp_Pnt& aPoint )
152 {
153   Standard_Real MaxDist2 = 0.0e0, curdist2;
154   gp_Pnt Result(0.0,0.0,0.0);
155   gp_Pnt curpnt(0.0,0.0,0.0);
156   TopExp_Explorer Explo( aShape, TopAbs_VERTEX );
157   for (; Explo.More(); Explo.Next())
158     {
159       curpnt = BRep_Tool::Pnt( TopoDS::Vertex( Explo.Current() ) );
160       curdist2 = aPoint.SquareDistance( curpnt );
161       if (curdist2 > MaxDist2)
162         {
163           MaxDist2 = curdist2;
164           Result = curpnt;
165         }
166     }
167   return Result;
168 }
169
170
171 //=======================================================================
172 //function : ComputeGeometry
173 //purpose  : for line, circle, ellipse.
174 //=======================================================================
175 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge&  theEdge,
176                                        Handle(Geom_Curve)& theCurve,
177                                        gp_Pnt&             theFirstPnt,
178                                        gp_Pnt&             theLastPnt)
179 {
180   TopLoc_Location anEdgeLoc;
181   Standard_Real aFirst, aLast;
182   theCurve = BRep_Tool::Curve (theEdge, anEdgeLoc, aFirst, aLast);
183   if (theCurve.IsNull())
184   {
185     return Standard_False;
186   }
187
188   if (!anEdgeLoc.IsIdentity())
189   {
190     Handle(Geom_Geometry) aGeometry = theCurve->Transformed (anEdgeLoc.Transformation());
191     theCurve = (Handle(Geom_Curve)&) aGeometry;
192   }
193
194   if (theCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
195   {
196     theCurve = ((Handle(Geom_TrimmedCurve)&) theCurve)->BasisCurve();
197   }
198
199   if (theCurve->IsInstance (STANDARD_TYPE (Geom_Line)))
200   {
201     Handle(Geom_Line) aLine = (Handle(Geom_Line)&) theCurve;
202     theFirstPnt = ElCLib::Value (aFirst, aLine->Lin());
203     theLastPnt = ElCLib::Value (aLast, aLine->Lin());
204   }
205   else if (theCurve->IsInstance (STANDARD_TYPE (Geom_Circle)))
206   {
207     Handle(Geom_Circle) aCirc = (Handle(Geom_Circle)&) theCurve;
208
209     theFirstPnt = ElCLib::Value (aFirst, aCirc->Circ());
210     theLastPnt = ElCLib::Value (aLast, aCirc->Circ());
211   }
212   else if (theCurve->IsInstance (STANDARD_TYPE (Geom_Ellipse)))
213   {
214     Handle(Geom_Ellipse) anEllipse = (Handle(Geom_Ellipse)&) theCurve;
215     theFirstPnt = ElCLib::Value (aFirst, anEllipse->Elips());
216     theLastPnt = ElCLib::Value (aLast, anEllipse->Elips());
217   }
218   else
219   {
220     return Standard_False;
221   }
222
223   return Standard_True;
224 }
225
226 //=======================================================================
227 //function : ComputeGeometry
228 //purpose  : for line, circle, ellipse.
229 //=======================================================================
230 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge& theEdge,
231                                        Handle(Geom_Curve)& theCurve,
232                                        gp_Pnt& theFirstPnt,
233                                        gp_Pnt& theLastPnt,
234                                        Standard_Boolean& theIsInfinite)
235 {
236   Standard_Real aFirst, aLast;
237
238   BRepAdaptor_Curve anAdaptor (theEdge);
239
240   theCurve = Handle(Geom_Curve)::DownCast
241     (anAdaptor.Curve().Curve()->Transformed (anAdaptor.Trsf()));
242
243   if (theCurve.IsNull())
244   {
245     return Standard_False;
246   }
247
248   aFirst = anAdaptor.FirstParameter();
249   aLast = anAdaptor.LastParameter();
250
251   theIsInfinite = (Precision::IsInfinite (aFirst) || Precision::IsInfinite (aLast));
252
253   if (theCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
254   {
255     theCurve = ((Handle(Geom_TrimmedCurve)&) theCurve)->BasisCurve();
256   }
257
258   if (!theIsInfinite)
259   {
260     theFirstPnt = theCurve->Value (aFirst);
261     theLastPnt  = theCurve->Value (aLast);
262   }
263   else
264   {
265     theFirstPnt = gp::Origin();
266     theLastPnt  = gp::Origin();
267   }
268
269   return Standard_True;
270 }
271
272 //=======================================================================
273 //function : ComputeGeometry
274 //purpose  :
275 //=======================================================================
276
277 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge& theEdge,
278                                        Handle(Geom_Curve)& theCurve,
279                                        gp_Pnt& theFirstPnt,
280                                        gp_Pnt& theLastPnt,
281                                        Handle(Geom_Curve)& theExtCurve,
282                                        Standard_Boolean& theIsInfinite,
283                                        Standard_Boolean& theIsOnPlane,
284                                        const Handle(Geom_Plane)& thePlane)
285 {
286   if (thePlane.IsNull())
287   {
288     return Standard_False;
289   }
290
291   Standard_Real aFirst, aLast;
292   BRepAdaptor_Curve aCurveAdaptor (theEdge);
293   theCurve = Handle(Geom_Curve)::DownCast (aCurveAdaptor.Curve().Curve()->Transformed (aCurveAdaptor.Trsf()));
294   aFirst = aCurveAdaptor.FirstParameter();
295   aLast = aCurveAdaptor.LastParameter();
296
297   if (theCurve.IsNull())
298   {
299     return Standard_False;
300   }
301   
302   theExtCurve = theCurve;
303   theIsInfinite = (Precision::IsInfinite (aFirst) || Precision::IsInfinite (aLast));
304
305   // Checks that the projected curve is not in the plane.
306   theIsOnPlane = Standard_True;
307   if (theExtCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
308   {
309     theExtCurve = ((Handle(Geom_TrimmedCurve)&) theExtCurve)->BasisCurve();
310   }
311
312   if (theExtCurve->IsInstance (STANDARD_TYPE (Geom_Line)))
313   {
314     Handle(Geom_Line) aLine = (Handle(Geom_Line)&) theExtCurve;
315     theIsOnPlane = thePlane->Pln().Contains (aLine->Lin(),
316                                              Precision::Confusion(),
317                                              Precision::Angular());
318   }
319   else if (theExtCurve->IsInstance (STANDARD_TYPE (Geom_Circle)))
320   {
321     Handle(Geom_Circle) aCircle = (Handle(Geom_Circle)&) theExtCurve;
322
323     gp_Ax3 aCircPos (aCircle->Position());
324     theIsOnPlane = aCircPos.IsCoplanar (thePlane->Pln().Position(),
325                                                 Precision::Confusion(),
326                                                 Precision::Angular());
327   }
328
329   if (theIsOnPlane)
330   {
331     theExtCurve.Nullify();
332   }
333
334   theCurve = GeomProjLib::ProjectOnPlane (theCurve, thePlane,
335                                           thePlane->Pln().Axis().Direction(),
336                                           Standard_False);
337
338   if (theCurve->IsInstance (STANDARD_TYPE (Geom_Line)))
339   {
340     Handle(Geom_Line) aLine = (Handle(Geom_Line)&) theCurve;
341     if (!theIsInfinite)
342     {
343       theFirstPnt = ElCLib::Value (aFirst, aLine->Lin());
344       theLastPnt = ElCLib::Value (aLast, aLine->Lin());
345     }
346   }
347   else if (theCurve->IsInstance (STANDARD_TYPE (Geom_Circle)))
348   {
349     Handle(Geom_Circle) aCirc = (Handle(Geom_Circle)&) theCurve;
350
351     theFirstPnt = ElCLib::Value (aFirst, aCirc->Circ());
352     theLastPnt = ElCLib::Value (aLast, aCirc->Circ());
353   }
354   else if (theCurve->IsInstance (STANDARD_TYPE (Geom_Ellipse)))
355     {
356       Handle(Geom_Ellipse) anEllipse = (Handle(Geom_Ellipse)&) theCurve;
357
358       theFirstPnt = ElCLib::Value (aFirst, anEllipse->Elips());
359       theLastPnt = ElCLib::Value (aLast, anEllipse->Elips());
360     }
361   else
362   {
363     return Standard_False;
364   }
365
366   return Standard_True;
367 }
368
369 //=======================================================================
370 //function : ComputeGeometry
371 //purpose  :
372 //=======================================================================
373 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge& theFirstEdge,
374                                       const TopoDS_Edge& theSecondEdge,
375                                       Handle(Geom_Curve)& theFirstCurve,
376                                       Handle(Geom_Curve)& theSecondCurve,
377                                       gp_Pnt& theFirstPnt1,
378                                       gp_Pnt& theLastPnt1,
379                                       gp_Pnt& theFirstPnt2,
380                                       gp_Pnt& theLastPnt2,
381                                       const Handle(Geom_Plane)& thePlane)
382 {
383   if (thePlane.IsNull())
384   {
385     return Standard_False;
386   }
387
388   TopLoc_Location aFirstEdgeLoc, aSecondEdgeLoc;
389   Standard_Real aFirst1, aLast1, aFirst2, aLast2;
390   
391   theFirstCurve = BRep_Tool::Curve (theFirstEdge, aFirstEdgeLoc, aFirst1, aLast1);
392   theSecondCurve = BRep_Tool::Curve (theSecondEdge, aSecondEdgeLoc, aFirst2, aLast2);
393
394   if (theFirstCurve.IsNull())
395   {
396     return Standard_False;
397   }
398     
399   if (theSecondCurve.IsNull())
400   {
401     return Standard_False;
402   }
403   
404   if (!aFirstEdgeLoc.IsIdentity())
405   {
406     Handle(Geom_Geometry) aGeomGeometry = theFirstCurve->Transformed (aFirstEdgeLoc.Transformation());
407     theFirstCurve = (Handle(Geom_Curve)&) aGeomGeometry;
408   }
409     
410   if (!aSecondEdgeLoc.IsIdentity())
411   {
412     Handle(Geom_Geometry) aGeomGeometry = theSecondCurve->Transformed (aSecondEdgeLoc.Transformation());
413     theSecondCurve = (Handle(Geom_Curve)&) aGeomGeometry;
414   }
415
416   theFirstCurve = GeomProjLib::ProjectOnPlane (theFirstCurve, thePlane,
417                                                thePlane->Pln().Axis().Direction(),
418                                                Standard_False);
419
420
421   theSecondCurve = GeomProjLib::ProjectOnPlane (theSecondCurve, thePlane,
422                                                 thePlane->Pln().Axis().Direction(),
423                                                 Standard_False);
424
425
426   if (theFirstCurve->IsInstance (STANDARD_TYPE(Geom_TrimmedCurve)))
427   {
428     theFirstCurve = ((Handle(Geom_TrimmedCurve)&) theFirstCurve)->BasisCurve();
429   }
430     
431   if (theSecondCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
432   {
433     theSecondCurve = ((Handle(Geom_TrimmedCurve)&) theSecondCurve)->BasisCurve();
434   }
435
436   if (theFirstCurve->IsInstance(STANDARD_TYPE(Geom_Line)))
437   {
438     Handle(Geom_Line) aLine = (Handle(Geom_Line)&) theFirstCurve;
439
440     theFirstPnt1 = ElCLib::Value (aFirst1, aLine->Lin());
441     theLastPnt1 = ElCLib::Value (aLast1, aLine->Lin());
442   }
443   else if (theFirstCurve->IsInstance(STANDARD_TYPE(Geom_Circle)))
444   {
445     Handle(Geom_Circle) aCirc = (Handle(Geom_Circle)&) theFirstCurve;
446       
447     theFirstPnt1 = ElCLib::Value (aFirst1, aCirc->Circ());
448     theLastPnt1 = ElCLib::Value (aLast1, aCirc->Circ());
449   }
450   else
451   {
452     return Standard_False;
453   }
454
455   if (theSecondCurve->IsInstance (STANDARD_TYPE (Geom_Line)))
456 {
457     Handle(Geom_Line) aLine = (Handle(Geom_Line)&) theSecondCurve;
458
459     theFirstPnt2 = ElCLib::Value (aFirst2, aLine->Lin());
460     theLastPnt2 = ElCLib::Value (aLast2, aLine->Lin());
461   }
462   else if (theSecondCurve->IsInstance (STANDARD_TYPE (Geom_Circle)))
463   {
464     Handle(Geom_Circle) aCirc = (Handle(Geom_Circle)&) theSecondCurve;
465
466     theFirstPnt2 = ElCLib::Value (aFirst2, aCirc->Circ());
467     theLastPnt2 = ElCLib::Value (aLast2, aCirc->Circ());
468   }
469   else
470   {
471     return Standard_False;
472   }
473
474   return Standard_True;
475 }
476
477 //=======================================================================
478 //function : ComputeGeometry
479 //purpose  : Computes the geometry of the 2 edges.
480 //=======================================================================
481 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge& theFirstEdge,
482                                        const TopoDS_Edge& theSecondEdge,
483                                        Handle(Geom_Curve)& theFirstCurve,
484                                        Handle(Geom_Curve)& theSecondCurve,
485                                        gp_Pnt& theFirstPnt1,
486                                        gp_Pnt& theLastPnt1,
487                                        gp_Pnt& theFirstPnt2,
488                                        gp_Pnt& theLastPnt2,
489                                        Standard_Boolean& theIsInfinite1,
490                                        Standard_Boolean& theIsInfinite2)
491 {
492     theIsInfinite1 = theIsInfinite2 = Standard_False;
493
494    if (!AIS::ComputeGeometry (theFirstEdge, theFirstCurve,theFirstPnt1, theLastPnt1, theIsInfinite1))
495    {
496      return Standard_False;
497    }
498
499    if (!AIS::ComputeGeometry (theSecondEdge, theSecondCurve,theFirstPnt2, theLastPnt2, theIsInfinite2))
500    {
501      return Standard_False;
502    }
503
504   if (theIsInfinite1 || theIsInfinite2)
505   {
506       if (theFirstCurve->DynamicType() == theSecondCurve->DynamicType())
507       {
508           gp_Lin aLin1 = ((Handle(Geom_Line)&) theFirstCurve)->Lin();
509           gp_Lin aLin2 = ((Handle(Geom_Line)&) theSecondCurve)->Lin();
510
511           if (theIsInfinite1)
512           {
513               theFirstPnt1 = ElCLib::Value (ElCLib::Parameter (aLin2, theFirstPnt2), aLin1);
514               theLastPnt1 = ElCLib::Value (ElCLib::Parameter (aLin2, theLastPnt2), aLin1);
515           }
516           else if (theIsInfinite2)
517           {
518               theFirstPnt2 = ElCLib::Value (ElCLib::Parameter (aLin1, theFirstPnt1), aLin2);
519               theLastPnt2 = ElCLib::Value (ElCLib::Parameter (aLin1, theLastPnt1), aLin2);
520           }
521       }
522       else
523       {
524         if (theIsInfinite1 && !theIsInfinite2)
525         {
526           GeomAPI_ProjectPointOnCurve aProjector (theFirstPnt2, theFirstCurve);
527           theFirstPnt1 = theFirstCurve->Value (aProjector.LowerDistanceParameter ());
528
529           aProjector.Init (theLastPnt2, theFirstCurve);
530           theLastPnt1 = theFirstCurve->Value (aProjector.LowerDistanceParameter ());
531         }
532         else if (!theIsInfinite1 && theIsInfinite2)
533         {
534           GeomAPI_ProjectPointOnCurve aProjector (theFirstPnt1, theSecondCurve);
535           theFirstPnt2 = theSecondCurve->Value (aProjector.LowerDistanceParameter ());
536
537           aProjector.Init (theLastPnt1, theSecondCurve);
538           theLastPnt2 = theSecondCurve->Value (aProjector.LowerDistanceParameter ());
539         }
540         else
541         {
542           return Standard_False;
543         }
544       }
545   }
546
547     return Standard_True;
548 }
549
550 //=======================================================================
551 //function : ComputeGeometry
552 //purpose  : Computes the geometry of the 2 edges in the current wp
553 //           and the 'right' geometry of the edges if one doesn't
554 //           belong to the current working plane.
555 //           There may be only one curve that can't belong to the
556 //           current working plane ( attachement constraint)
557 //           if the 2 edges belong to the current WP, <WhatProj> = 0
558 //
559 //           indexExt = 0 2 edges are in the current wp
560 //           indexExt = 1 first edge is not in the current wp
561 //           indexExt = 2 second edge is not in the current wp
562 //           if none of the two edges is in the current wp ,
563 //           it returns Standard_False
564 //=======================================================================
565 Standard_Boolean AIS::ComputeGeometry (const TopoDS_Edge& theFirstEdge,
566                                        const TopoDS_Edge& theSecondEdge,
567                                        Standard_Integer& theExtIndex,
568                                        Handle(Geom_Curve)& theFirstCurve,
569                                        Handle(Geom_Curve)& theSecondCurve,
570                                        gp_Pnt& theFirstPnt1,
571                                        gp_Pnt& theLastPnt1,
572                                        gp_Pnt& theFirstPnt2,
573                                        gp_Pnt& theLastPnt2,
574                                        Handle(Geom_Curve)& theExtCurve,
575                                        Standard_Boolean& theIsInfinite1,
576                                        Standard_Boolean& theIsInfinite2,
577                                        const Handle(Geom_Plane)& thePlane)
578 {
579   if (thePlane.IsNull())
580   {
581     return Standard_False;
582   }
583
584   theExtCurve.Nullify();
585   theExtIndex = 0;
586
587   Standard_Real aFirst1, aLast1, aFirst2, aLast2;
588   theIsInfinite1 = theIsInfinite2 = Standard_False;
589
590   BRepAdaptor_Curve aFirstAdaptor (theFirstEdge);
591   BRepAdaptor_Curve aSecondAdaptor (theSecondEdge);
592
593   theFirstCurve = Handle(Geom_Curve)::DownCast
594                   (aFirstAdaptor.Curve().Curve()->Transformed (aFirstAdaptor.Trsf()));
595   theSecondCurve = Handle(Geom_Curve)::DownCast
596                   (aSecondAdaptor.Curve().Curve()->Transformed (aSecondAdaptor.Trsf()));
597
598   if (theFirstCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
599   {
600     theFirstCurve = ((Handle(Geom_TrimmedCurve)&) theFirstCurve)->BasisCurve();
601   }
602   if (theSecondCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
603   {
604     theSecondCurve = ((Handle(Geom_TrimmedCurve)&) theSecondCurve)->BasisCurve();
605   }
606
607   aFirst1 = aFirstAdaptor.FirstParameter();
608   aLast1 = aFirstAdaptor.LastParameter();
609
610   aFirst2 = aSecondAdaptor.FirstParameter();
611   aLast2 = aSecondAdaptor.LastParameter();
612
613   if (theFirstCurve.IsNull() || theSecondCurve.IsNull())
614   {
615     return Standard_False;
616   }
617
618   Handle(Geom_Curve) aFirstSaved = theFirstCurve;
619   Handle(Geom_Curve) aSecondSaved = theSecondCurve;
620
621   // Checks that the projected curve is not in the plane
622   Standard_Boolean isFirstOnPlane,isSecondOnPlane;
623
624   if ((!ComputeGeomCurve (theFirstCurve, aFirst1, aLast1, theFirstPnt1, theLastPnt1, thePlane, isFirstOnPlane))
625       || (!ComputeGeomCurve( theSecondCurve, aFirst2, aLast2, theFirstPnt2, theLastPnt2, thePlane,isSecondOnPlane)))
626   {
627     return Standard_False;
628   }
629
630   if (Precision::IsInfinite (aFirst1) || Precision::IsInfinite (aLast1))
631   {
632     theIsInfinite1 = Standard_True;
633     theExtIndex = 1;
634   }
635   if (Precision::IsInfinite (aFirst2) || Precision::IsInfinite (aLast2))
636   {
637     theIsInfinite2 = Standard_True;
638     theExtIndex = 2;
639   }
640   if (theIsInfinite1 && theIsInfinite2)
641   {
642     theExtIndex = 0;
643   }
644
645   if (theIsInfinite1 || theIsInfinite2)
646   {
647     if (theFirstCurve->DynamicType() == theSecondCurve->DynamicType())
648     {
649       gp_Lin aLin1 = ((Handle(Geom_Line)&) theFirstCurve)->Lin();
650       gp_Lin aLin2 = ((Handle(Geom_Line)&) theSecondCurve)->Lin();
651
652       if (theExtIndex == 1)
653       {
654         theFirstPnt1 = ElCLib::Value (ElCLib::Parameter (aLin2, theFirstPnt2), aLin1);
655         theLastPnt1 = ElCLib::Value (ElCLib::Parameter (aLin2, theLastPnt2), aLin1);
656       }
657       else if (theExtIndex == 2)
658       {
659         theFirstPnt2 = ElCLib::Value (ElCLib::Parameter (aLin1, theFirstPnt1), aLin2);
660         theLastPnt2 = ElCLib::Value (ElCLib::Parameter (aLin1, theLastPnt1), aLin2);
661       }
662     }
663   }
664
665   if (isFirstOnPlane && isSecondOnPlane)
666   {
667     return Standard_True;
668   }
669
670   if (!isFirstOnPlane && isSecondOnPlane)
671   {// curve 2 only in the plane
672     theExtIndex = 1;
673     theExtCurve = aFirstSaved;
674   }
675   else if (isFirstOnPlane && !isSecondOnPlane)
676   {// curve 1 only in the plane
677     theExtIndex = 2;
678     theExtCurve = aSecondSaved;
679   }
680   else
681   {
682     return Standard_False;
683   }
684
685   return Standard_True;
686 }
687
688 //=======================================================================
689 //function : ComputeGeomCurve
690 //purpose  : Checks if aCurve belongs to aPlane; if not, projects aCurve in aPlane
691 //           and returns aCurveproj;
692 //           Return TRUE if ok
693 //=======================================================================
694 Standard_Boolean AIS::ComputeGeomCurve (Handle(Geom_Curve)& aCurve,
695                                         const Standard_Real first1,
696                                         const Standard_Real last1,
697                                         gp_Pnt& FirstPnt1,
698                                         gp_Pnt& LastPnt1,
699                                         const Handle(Geom_Plane)& aPlane,
700                                         Standard_Boolean& isOnPlane)
701 {
702   isOnPlane = Standard_True;
703   const Standard_Integer NodeNumber = 20;
704   Standard_Real Delta = (last1 - first1) / (NodeNumber - 1);
705   if (Delta <= Precision::PConfusion())
706   {
707     Delta = last1 - first1;
708   }
709
710   gp_Pnt CurPnt(0.0, 0.0, 0.0);
711   Standard_Real CurPar = first1;
712   for (Standard_Integer i = 1; i <= NodeNumber; i++)
713   {
714     CurPnt = aCurve->Value( CurPar );
715     if (aPlane->Pln().SquareDistance( CurPnt ) > SquareTolerance)
716     {
717       isOnPlane = Standard_False;
718       break;
719     }
720     CurPar += Delta;
721   }
722
723   if (!Precision::IsInfinite(first1) && !Precision::IsInfinite(last1))
724   {
725     FirstPnt1 = aCurve->Value (first1);
726     LastPnt1  = aCurve->Value (last1);
727   }
728
729   if (!isOnPlane)
730   {
731     Handle(Geom_Curve) aGeomCurve = GeomProjLib::ProjectOnPlane (aCurve,
732                                                                 aPlane,
733                                                                 aPlane->Pln().Axis().Direction(),
734                                                                 Standard_False);
735     aCurve = aGeomCurve;
736     if (aCurve->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
737     {
738       aCurve = ((Handle(Geom_TrimmedCurve)&) aCurve)->BasisCurve();
739     }
740     if (! Precision::IsInfinite(first1) && ! Precision::IsInfinite(last1))
741     {
742       FirstPnt1 = AIS::ProjectPointOnPlane( FirstPnt1, aPlane->Pln() );
743       LastPnt1 = AIS::ProjectPointOnPlane( LastPnt1, aPlane->Pln() );
744     }
745   }
746   return Standard_True;
747 }
748
749 //=======================================================================
750 //function : ComputeGeometry
751 //purpose  : computes the point corresponding to the vertex <aVertex>
752 //           in the plane <aPlane>. If the vertex is already in the plane
753 //           <isOnPlane>, <isOnPlane> = true.
754 //           <point> is the projected vertex in the plane.
755 //=======================================================================
756 Standard_Boolean  AIS::ComputeGeometry(const TopoDS_Vertex& aVertex,
757                                        gp_Pnt& point,
758                                        const Handle(Geom_Plane)& aPlane,
759                                        Standard_Boolean& isOnPlane)
760 {
761   point = BRep_Tool::Pnt(aVertex);
762   isOnPlane = aPlane->Pln().Contains(point,  Precision::Confusion());
763   if ( !isOnPlane) {
764     point = AIS::ProjectPointOnPlane( point, aPlane->Pln() );
765   }
766   return Standard_True;
767 }
768
769 //=======================================================================
770 //function : GetPlaneFromFace
771 //purpose  :
772 //           Returns type of surface which can be Plane or OtherSurface
773 //=======================================================================
774 Standard_Boolean AIS::GetPlaneFromFace(const TopoDS_Face&            aFace,
775                                         gp_Pln &                     aPlane,
776                                         Handle( Geom_Surface )&      aSurf,
777                                         AIS_KindOfSurface &          aSurfType,
778                                         Standard_Real &              Offset)
779
780 {
781   Standard_Boolean Result = Standard_False;
782   BRepAdaptor_Surface surf1( aFace );
783   Handle( Adaptor3d_HSurface ) surf2;
784   Standard_Boolean isOffset = Standard_False;
785
786   if (surf1.GetType() == GeomAbs_OffsetSurface)
787   {
788     // Extracting Basis Surface
789     surf2 = surf1.BasisSurface();
790     isOffset = Standard_True;
791   }
792   else
793     surf2 = new BRepAdaptor_HSurface( surf1 );
794
795   aSurf = surf1.Surface().Surface();
796   //  aSurf->Transform(surf1.Trsf()) ;
797   aSurf = Handle( Geom_Surface )::DownCast( aSurf->Transformed( surf1.Trsf() ) );
798
799   if (surf2->GetType() == GeomAbs_Plane)
800   {
801     aPlane = surf2->Plane();
802     aSurfType = AIS_KOS_Plane;
803     Offset = 0.;
804     Result = Standard_True;
805   }
806
807   else if (surf2->GetType() == GeomAbs_SurfaceOfExtrusion)
808   {
809     Handle( Adaptor3d_HCurve ) BasisCurve = surf2->BasisCurve();
810     gp_Dir ExtrusionDir = surf2->Direction();
811     if (BasisCurve->GetType() == GeomAbs_Line)
812     {
813       gp_Lin BasisLine = BasisCurve->Line();
814       gp_Dir LineDir = BasisLine.Direction();
815       gp_Pnt LinePos = BasisLine.Location();
816       gp_Pln thePlane( LinePos, LineDir ^ ExtrusionDir);
817       aPlane = thePlane;
818       aSurfType = AIS_KOS_Plane;
819       Offset = 0.;
820       Result = Standard_True;
821     }
822   }
823
824   if (Result == Standard_True && isOffset)
825   {
826     aSurf = (Handle( Geom_OffsetSurface )::DownCast( aSurf ))->Surface();
827     aPlane = (Handle( Geom_Plane )::DownCast( aSurf ))->Pln();
828     Offset = 0.0e0;
829   }
830   if (Result == Standard_False)
831   {
832     if (isOffset)
833     {
834       Handle( Standard_Type ) TheType = aSurf->DynamicType();
835       if (TheType == STANDARD_TYPE(Geom_CylindricalSurface) ||
836         TheType == STANDARD_TYPE(Geom_ConicalSurface)     ||
837         TheType == STANDARD_TYPE(Geom_SphericalSurface)   ||
838         TheType == STANDARD_TYPE(Geom_ToroidalSurface))
839       {
840         aSurf = (Handle( Geom_OffsetSurface )::DownCast( aSurf ))->Surface();
841         Offset = 0.0e0;
842       }
843       else
844       {
845         Offset = (Handle( Geom_OffsetSurface )::DownCast( aSurf ))->Offset();
846         aSurf =  (Handle( Geom_OffsetSurface )::DownCast( aSurf ))->BasisSurface();
847       }
848     }
849     Handle( Standard_Type ) TheType = aSurf->DynamicType();
850     if (TheType == STANDARD_TYPE(Geom_CylindricalSurface))
851       aSurfType = AIS_KOS_Cylinder;
852     else if (TheType == STANDARD_TYPE(Geom_ConicalSurface))
853       aSurfType = AIS_KOS_Cone;
854     else if (TheType == STANDARD_TYPE(Geom_SphericalSurface))
855       aSurfType = AIS_KOS_Sphere;
856     else if (TheType == STANDARD_TYPE(Geom_ToroidalSurface))
857       aSurfType = AIS_KOS_Torus;
858     else if (TheType == STANDARD_TYPE(Geom_SurfaceOfRevolution))
859       aSurfType = AIS_KOS_Revolution;
860     else if (TheType == STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))
861       aSurfType = AIS_KOS_Extrusion;
862     else
863       aSurfType = AIS_KOS_OtherSurface;
864   }
865   return Result;
866 }
867
868
869 //=======================================================================
870 //function : ProjectPointOnPlane
871 //purpose  :
872 //=======================================================================
873
874 gp_Pnt AIS::ProjectPointOnPlane( const gp_Pnt & aPoint, const gp_Pln & aPlane )
875 {
876   gp_Vec aVec( aPlane.Location(), aPoint );
877   gp_Vec Normal = aPlane.Axis().Direction();
878   Normal = (aVec * Normal) * Normal;
879
880   return ( aPoint.Translated( -Normal ) );
881 }
882
883 //=======================================================================
884 //function : ProjectPointOnLine
885 //purpose  :
886 //=======================================================================
887
888 gp_Pnt AIS::ProjectPointOnLine( const gp_Pnt & aPoint, const gp_Lin & aLine )
889 {
890   gp_XYZ LinLoc = aLine.Location().XYZ();
891   gp_XYZ LinDir = aLine.Direction().XYZ();
892   Standard_Real Parameter = (aPoint.XYZ() - LinLoc) * LinDir;
893   gp_Pnt Result( LinLoc + Parameter * LinDir );
894   return Result;
895 }
896
897 //=======================================================================
898 //function : InitFaceLength
899 //purpose  : 
900 //=======================================================================
901 void AIS::InitFaceLength (const TopoDS_Face& aFace,
902                           gp_Pln               & aPlane,
903                           Handle(Geom_Surface) & aSurface,
904                           AIS_KindOfSurface    & aSurfaceType,
905                           Standard_Real        & anOffset)
906 {
907   AIS::GetPlaneFromFace( aFace, aPlane, aSurface, aSurfaceType, anOffset );
908   
909   if (Abs( anOffset ) > Precision::Confusion())
910     {
911       aSurface = new Geom_OffsetSurface( aSurface, anOffset );
912       anOffset = 0.0e0;
913     }
914   
915 }
916
917 //=======================================================================
918 //function : InitAngleBetweenPlanarFaces
919 //purpose  :
920 //=======================================================================
921 Standard_Boolean AIS::InitAngleBetweenPlanarFaces (const TopoDS_Face&          theFirstFace,
922                                                    const TopoDS_Face&          theSecondFace,
923                                                    gp_Pnt &                    theCenter,
924                                                    gp_Pnt &                    theFirstAttach,
925                                                    gp_Pnt &                    theSecondAttach,
926                                                    const Standard_Boolean      theIsFirstPointSet)
927 {
928   Handle(Geom_Plane) aFirstPlane = Handle(Geom_Plane)::DownCast (BRep_Tool::Surface (theFirstFace));
929   Handle(Geom_Plane) aSecondPlane = Handle(Geom_Plane)::DownCast (BRep_Tool::Surface (theSecondFace));
930
931   GeomAPI_IntSS aPlaneIntersector (aFirstPlane, aSecondPlane, Precision::Confusion());
932
933   // Fails if two planes haven't only one intersection line.
934   if (!aPlaneIntersector.IsDone())
935   {
936     return Standard_False;
937   }
938
939   if (aPlaneIntersector.NbLines() != 1)
940   {
941     return Standard_False;
942   }
943
944   // Get intersect line.
945   Handle(Geom_Curve) anIntersectCurve = aPlaneIntersector.Line (1);
946
947   Handle(Geom_Line) anIntersectLine = Handle(Geom_Line)::DownCast (anIntersectCurve);
948
949   if (anIntersectLine.IsNull())
950   {
951     return Standard_False;
952   }
953
954   gp_Lin anIntersectLin = anIntersectLine->Lin();
955
956   gp_Pnt aFirstCenter, aSecondCenter;
957   Standard_Real anU1Min, anU1Max, aV1Min, aV1Max;
958   Standard_Real anU2Min, anU2Max, aV2Min, aV2Max;
959
960   BRepTools::UVBounds (theFirstFace, anU1Min, anU1Max, aV1Min, aV1Max);
961   BRepTools::UVBounds (theSecondFace, anU2Min, anU2Max, aV2Min, aV2Max);
962
963   // Get first and second attach.
964   if (theIsFirstPointSet)
965   {
966     GeomAPI_ProjectPointOnSurf aProjector (theFirstAttach, aFirstPlane);
967     if (!aProjector.IsDone())
968     {
969       return Standard_False;
970     }
971
972     aFirstCenter = aProjector.Point (1);
973   }
974   else
975   {
976     aFirstCenter = aFirstPlane->Value ((anU1Min + anU1Max) * 0.5, (aV1Min + aV1Max) * 0.5);
977   }
978
979   aSecondCenter = aSecondPlane->Value ((anU2Min + anU2Max) * 0.5, (aV2Min + aV2Max) * 0.5);
980
981   GeomAPI_ProjectPointOnCurve aProj (aFirstCenter, anIntersectCurve);
982   theCenter = aProj.NearestPoint();
983
984   gp_Vec aFirstNormal = anIntersectLin.Direction() ^ aFirstPlane->Pln().Axis().Direction();
985   if (aFirstNormal * gp_Vec (theCenter, aFirstCenter) < 0.0)
986   {
987     aFirstNormal.Reverse();
988   }
989   theFirstAttach = theCenter.Translated (aFirstNormal);
990
991   gp_Vec aSecondNormal = anIntersectLin.Direction() ^ aSecondPlane->Pln().Axis().Direction();
992   if (aSecondNormal * gp_Vec (theCenter, aSecondCenter) < 0.0)
993   {
994     aSecondNormal.Reverse();
995   }
996   theSecondAttach = theCenter.Translated (aSecondNormal);
997
998   return Standard_True;
999 }
1000
1001 //=======================================================================
1002 //function : InitAngleBetweenCurvilinearFaces
1003 //purpose  :
1004 //=======================================================================
1005 Standard_Boolean AIS::InitAngleBetweenCurvilinearFaces (const TopoDS_Face&          theFirstFace,
1006                                                         const TopoDS_Face&          theSecondFace,
1007                                                         const AIS_KindOfSurface     theFirstSurfType,
1008                                                         const AIS_KindOfSurface     theSecondSurfType,
1009                                                         gp_Pnt&                     theCenter,
1010                                                         gp_Pnt&                     theFirstAttach,
1011                                                         gp_Pnt&                     theSecondAttach,
1012                                                         const Standard_Boolean      theIsFirstPointSet)
1013 {
1014   Handle(Geom_Surface) aFirstSurf = BRep_Tool::Surface (theFirstFace);
1015   Handle(Geom_Surface) aSecondSurf = BRep_Tool::Surface (theSecondFace);
1016
1017   // Find intersection curve between two surfaces.
1018   GeomAPI_IntSS aSurfaceIntersector (aFirstSurf, aSecondSurf, Precision::Confusion());
1019
1020   // Fails if two planes haven't only one intersection line.
1021   if (!aSurfaceIntersector.IsDone())
1022   {
1023     return Standard_False;
1024   }
1025
1026   if (aSurfaceIntersector.NbLines() != 1)
1027   {
1028     return Standard_False;
1029   }
1030
1031   // Get intersect line.
1032   Handle(Geom_Curve) anIntersectCurve = aSurfaceIntersector.Line (1);
1033
1034   Handle(Geom_Line) aFirstLine, aSecondLine;
1035   Standard_Real aFirstU = 0.0;
1036   Standard_Real aFirstV = 0.0;
1037
1038   if (theIsFirstPointSet)
1039   {
1040     GeomAPI_ProjectPointOnSurf aProjector (theFirstAttach, aFirstSurf);
1041     if (!aProjector.IsDone())
1042     {
1043       return Standard_False;
1044     }
1045
1046     theFirstAttach = aProjector.Point (1);
1047   }
1048   else
1049   {
1050     theFirstAttach = aFirstSurf->Value (aFirstU, aFirstV);
1051   }
1052
1053   aFirstLine = Handle(Geom_Line)::DownCast (aFirstSurf->UIso (aFirstU));
1054
1055   if (theSecondSurfType == AIS_KOS_Cylinder)
1056   {
1057     Handle(Geom_CylindricalSurface) aCylinder = Handle(Geom_CylindricalSurface)::DownCast (aSecondSurf);
1058
1059     Standard_Real aSecondU = aCylinder->Cylinder().XAxis().Direction().Angle(
1060                                gce_MakeDir (ProjectPointOnLine (theFirstAttach,
1061                                                                 gp_Lin (aCylinder->Cylinder().Axis())),
1062                                             theFirstAttach));
1063
1064     aSecondLine = Handle(Geom_Line)::DownCast (aCylinder->UIso (aSecondU));
1065   }
1066   else if (theSecondSurfType == AIS_KOS_Cone)
1067   {
1068     Handle(Geom_ConicalSurface) aCone = Handle(Geom_ConicalSurface)::DownCast (aSecondSurf);
1069
1070     gp_Dir anXdirection = aCone->Cone().XAxis().Direction();
1071
1072     gp_Dir aToFirstAttach = gce_MakeDir (ProjectPointOnLine (theFirstAttach,
1073                                                              gp_Lin (aCone->Cone().Axis())),
1074                                          theFirstAttach);
1075
1076     Standard_Real aSecondU = anXdirection.Angle (aToFirstAttach);
1077
1078     // Check sign
1079     if (!anXdirection.IsEqual (aToFirstAttach, Precision::Angular()) &&
1080         !anXdirection.IsOpposite (aToFirstAttach, Precision::Angular()) &&
1081         (anXdirection ^ aToFirstAttach) * aCone->Cone().Axis().Direction() < 0.0)
1082     {
1083       aSecondU = 2*M_PI - aSecondU;
1084     }
1085     aSecondLine = Handle( Geom_Line )::DownCast (aCone->UIso(aSecondU));
1086   }
1087   else
1088   {
1089     return Standard_False;
1090   }
1091
1092   // If angle can be computed between two lines.
1093   if (!(aFirstLine->Lin().Direction().IsEqual (aSecondLine->Lin().Direction(), Precision::Angular() )) &&
1094       !(aFirstLine->Lin().Direction().IsOpposite (aSecondLine->Lin().Direction(), Precision::Angular())))
1095   {
1096     GeomAPI_ExtremaCurveCurve anIntersector (aFirstLine, aSecondLine);
1097     anIntersector.Points (1, theCenter, theCenter);
1098
1099     // Move theFirstAttach on aFirstLine if it is on theCenter.
1100     if (theCenter.SquareDistance(theFirstAttach ) <= SquareTolerance)
1101     {
1102       gp_Vec aDir (aFirstLine->Lin().Direction());
1103       theFirstAttach = theCenter.Translated (aDir);
1104
1105       // theFirstAttach should be on theFirstSurf.
1106       Standard_Real anU, aV;
1107       if (theFirstSurfType == AIS_KOS_Cylinder)
1108       {
1109         ElSLib::Parameters ((Handle(Geom_CylindricalSurface)::DownCast (aFirstSurf))->Cylinder(),
1110                             theFirstAttach, anU, aV);
1111
1112         theFirstAttach = ElSLib::Value (aFirstU, aV,
1113                                         (Handle( Geom_CylindricalSurface )::DownCast (aFirstSurf))->Cylinder() );
1114       }
1115       else if (theFirstSurfType == AIS_KOS_Cone)
1116       {
1117         ElSLib::Parameters ((Handle(Geom_ConicalSurface)::DownCast (aFirstSurf))->Cone(),
1118                              theFirstAttach, anU, aV);
1119         theFirstAttach = ElSLib::Value (aFirstU, aV,
1120                                        (Handle(Geom_ConicalSurface)::DownCast (aFirstSurf))->Cone());
1121       }
1122       else
1123       {
1124         return Standard_False;
1125       }
1126     }
1127
1128     // Find theSecondAttach
1129     GeomAPI_ProjectPointOnSurf aProjector (theFirstAttach, aSecondSurf);
1130     if (!aProjector.IsDone())
1131     {
1132       return Standard_False;
1133     }
1134     Quantity_Parameter anU, aV;
1135     aProjector.LowerDistanceParameters (anU, aV);
1136     theSecondAttach = aSecondSurf->Value (anU, aV);
1137   }
1138   else // aFirstLine and aSecondLine are coincident
1139   {
1140       gp_Vec aDir (aFirstLine->Lin().Direction());
1141       theFirstAttach = theCenter.Translated (aDir);
1142       theSecondAttach = theCenter.Translated (-aDir);
1143   }
1144   return Standard_True;
1145 }
1146
1147 //=======================================================================
1148 //function : ComputeLengthBetweenCurvilinearFaces
1149 //purpose  : 
1150 //=======================================================================
1151 void AIS::InitLengthBetweenCurvilinearFaces (const TopoDS_Face&    theFirstFace,
1152                                              const TopoDS_Face&    theSecondFace,
1153                                              Handle(Geom_Surface)& theFirstSurf,
1154                                              Handle(Geom_Surface)& theSecondSurf,
1155                                              gp_Pnt&               theFirstAttach,
1156                                              gp_Pnt&               theSecondAttach,
1157                                              gp_Dir&               theDirOnPlane)
1158 {
1159   GeomAPI_ProjectPointOnSurf aProjector;
1160   Quantity_Parameter aPU, aPV;
1161
1162   TopExp_Explorer anExplorer (theFirstFace, TopAbs_VERTEX);
1163
1164   theFirstAttach = BRep_Tool::Pnt (TopoDS::Vertex (anExplorer.Current()));
1165   aProjector.Init (theFirstAttach, theFirstSurf);
1166
1167   theFirstAttach = aProjector.NearestPoint();
1168   aProjector.LowerDistanceParameters (aPU, aPV);
1169
1170   gp_Vec aD1U, aD1V;
1171   theFirstSurf->D1 (aPU, aPV, theFirstAttach, aD1U, aD1V);
1172
1173   if (aD1U.SquareMagnitude() <= SquareTolerance || aD1V.SquareMagnitude() <= SquareTolerance)
1174   {
1175     theFirstAttach = AIS::Farest (theFirstFace, theFirstAttach);
1176     aProjector.Init (theFirstAttach, theFirstSurf);
1177     aProjector.LowerDistanceParameters (aPU, aPV);
1178     theFirstSurf->D1 (aPU, aPV, theFirstAttach, aD1U, aD1V);
1179   }
1180
1181   aD1U.Normalize();
1182   aD1V.Normalize();
1183
1184   theDirOnPlane = gp_Dir (aD1U);
1185
1186   gp_Dir aFirstSurfN = gp_Dir (aD1U ^ aD1V);
1187
1188   aProjector.Init (theFirstAttach, theSecondSurf);
1189
1190   Standard_Integer aBestPointIndex = 0;
1191   Quantity_Length aMinDist = RealLast();
1192   gp_Dir aLocalDir;
1193
1194   for (Standard_Integer aPointIt = 1; aPointIt <= aProjector.NbPoints(); aPointIt++)
1195   {
1196     aProjector.Parameters (aPointIt, aPU, aPV);
1197
1198     theSecondSurf->D1 (aPU, aPV, theSecondAttach, aD1U, aD1V);
1199
1200     aLocalDir = aD1U.SquareMagnitude() <= SquareTolerance || aD1V.SquareMagnitude() <= SquareTolerance
1201               ? gp_Dir (gp_Vec (theFirstAttach, aProjector.Point (aPointIt)))
1202               : gp_Dir (aD1U ^ aD1V);
1203
1204     if (aFirstSurfN.IsParallel (aLocalDir, Precision::Angular()) && aProjector.Distance (aPointIt) < aMinDist)
1205     {
1206       aBestPointIndex = aPointIt;
1207       aMinDist = aProjector.Distance (aPointIt);
1208     }
1209   }
1210
1211   if (aBestPointIndex == 0)
1212   {
1213     theSecondAttach = theFirstAttach;
1214   }
1215   else
1216   {
1217     theSecondAttach = aProjector.Point (aBestPointIndex);
1218     aProjector.Parameters (aBestPointIndex, aPU, aPV);
1219
1220     // Now there is projection of FirstAttach onto SecondSurf in aProjector
1221     BRepTopAdaptor_FClass2d aClassifier (theSecondFace, Precision::Confusion());
1222
1223     TopAbs_State aState = 
1224       aClassifier.Perform (gp_Pnt2d (aPU, aPV), theSecondSurf->IsUPeriodic() || theSecondSurf->IsVPeriodic());
1225
1226     if (aState == TopAbs_OUT || aState == TopAbs_UNKNOWN)
1227     {
1228       theSecondAttach = AIS::Nearest (theSecondFace, theSecondAttach);
1229     }
1230   }
1231 }
1232
1233 gp_Pnt AIS::TranslatePointToBound( const gp_Pnt & aPoint, const gp_Dir & aDir, const Bnd_Box & aBndBox )
1234 {
1235   if (aBndBox.IsOut( aPoint ))
1236     return aPoint;
1237   else
1238     {
1239       gp_Pnt Result(0.0,0.0,0.0);
1240       TColStd_Array2OfReal Bound( 1, 3, 1, 2 );
1241       TColStd_Array1OfReal Origin( 1, 3 );
1242       TColStd_Array1OfReal Dir( 1, 3 );
1243       Standard_Real t;
1244       
1245       aBndBox.Get( Bound(1,1), Bound(2,1), Bound(3,1), Bound(1,2),  Bound(2,2), Bound(3,2) );
1246       aPoint.Coord( Origin(1), Origin(2), Origin(3) );
1247       aDir.Coord( Dir(1), Dir(2), Dir(3) );
1248
1249       Bnd_Box EnlargedBox = aBndBox;
1250       EnlargedBox.Enlarge( aBndBox.GetGap() + Precision::Confusion() );
1251
1252       Standard_Boolean IsFound = Standard_False;
1253       for (Standard_Integer i = 1; i <= 3; i++)
1254         {
1255           if (Abs( Dir( i ) ) <= gp::Resolution())
1256             continue;
1257           for (Standard_Integer j = 1; j <= 2; j++)
1258             {
1259               t = (Bound( i, j ) - Origin( i )) / Dir( i );
1260               if (t < 0.0e0)
1261                 continue;
1262               Result = aPoint.Translated( gp_Vec( aDir ) * t );
1263               if (! EnlargedBox.IsOut( Result ))
1264                 {
1265                   IsFound = Standard_True;
1266                   break;
1267                 }
1268             }
1269           if (IsFound) break;
1270         }
1271       return Result;
1272     }
1273 }
1274
1275
1276 //=======================================================================
1277 //function : InDomain
1278 //purpose  : 
1279 //=======================================================================
1280
1281 Standard_Boolean AIS::InDomain(const Standard_Real fpar,
1282                                const Standard_Real lpar,
1283                                const Standard_Real para) 
1284 {
1285   if (fpar >= 0.) {
1286     if(lpar > fpar)
1287       return ((para >= fpar) && (para <= lpar));
1288     else { // fpar > lpar
1289       Standard_Real delta = 2*M_PI-fpar;
1290       Standard_Real lp, par, fp;
1291       lp = lpar + delta;
1292       par = para + delta;
1293       while(lp > 2*M_PI) lp-=2*M_PI;
1294       while(par > 2*M_PI) par-=2*M_PI;
1295       fp = 0.;
1296       return ((par >= fp) && (par <= lp));
1297     }
1298       
1299   }
1300   if (para >= (fpar+2*M_PI)) return Standard_True;
1301   if (para <= lpar) return Standard_True;
1302   return Standard_False;
1303 }
1304
1305 //=======================================================================
1306 //function : DistanceFromApex
1307 //purpose  : calculates parametric length arc of ellipse
1308 //=======================================================================
1309
1310 Standard_Real AIS::DistanceFromApex(const gp_Elips & elips,
1311                                     const gp_Pnt   & Apex,
1312                                     const Standard_Real par)
1313 {
1314   Standard_Real dist;
1315   Standard_Real parApex = ElCLib::Parameter ( elips, Apex );
1316   if(parApex == 0.0 || parApex == M_PI) 
1317     {//Major case
1318       if(parApex == 0.0) //pos Apex
1319         dist = (par < M_PI) ? par : (2*M_PI - par);
1320       else //neg Apex
1321         dist = (par < M_PI) ? ( M_PI - par) : ( par - M_PI );
1322     }
1323   else 
1324     {// Minor case
1325       if(parApex == M_PI / 2) //pos Apex
1326         {
1327           if(par <= parApex + M_PI && par > parApex) // 3/2*M_PI < par < M_PI/2
1328             dist = par - parApex;
1329           else 
1330             { 
1331               if(par >  parApex + M_PI) // 3/2*M_PI < par < 2*M_PI
1332                 dist = 2*M_PI - par + parApex;
1333               else
1334                 dist = parApex - par; 
1335             }
1336           }
1337       else //neg Apex == 3/2*M_PI
1338         {
1339           if(par <= parApex && par >= M_PI/2) // M_PI/2 < par < 3/2*M_PI
1340             dist = parApex - par;
1341           else
1342             {
1343               if(par >  parApex) // 3/2*M_PI < par < 2*M_PI
1344                 dist = par - parApex;
1345               else
1346                 dist = par + M_PI/2; // 0 < par < M_PI/2
1347             }
1348         }
1349     }
1350   return dist;
1351 }
1352
1353 //=======================================================================
1354 //function : NearestApex
1355 //purpose  : 
1356 //=======================================================================
1357
1358 gp_Pnt AIS::NearestApex(const gp_Elips & elips,
1359                         const gp_Pnt   & pApex,
1360                         const gp_Pnt   & nApex,
1361                         const Standard_Real fpara,
1362                         const Standard_Real lpara,
1363                               Standard_Boolean & IsInDomain)
1364 {
1365   Standard_Real parP, parN;
1366   gp_Pnt EndOfArrow(0.0,0.0,0.0);
1367   IsInDomain = Standard_True;
1368   parP = ElCLib::Parameter ( elips, pApex );
1369   if(InDomain(fpara, lpara, parP)) EndOfArrow = pApex;
1370   else 
1371     {
1372       parN = ElCLib::Parameter ( elips, nApex );
1373       if(InDomain(fpara, lpara, parN)) EndOfArrow = nApex;
1374       else {
1375         IsInDomain = Standard_False;
1376         Standard_Real posd = Min(DistanceFromApex (elips,pApex, fpara), 
1377                                  DistanceFromApex (elips,pApex, lpara));
1378         Standard_Real negd = Min(DistanceFromApex (elips,nApex, fpara), 
1379                                  DistanceFromApex (elips,nApex, lpara));
1380         if( posd < negd ) 
1381           EndOfArrow = pApex;
1382         else
1383           EndOfArrow = nApex;
1384       }
1385     }
1386   return EndOfArrow;
1387 }
1388
1389 //=======================================================================
1390 //function : ComputeProjEdgePresentation
1391 //purpose  : 
1392 //=======================================================================
1393
1394 void AIS::ComputeProjEdgePresentation (const Handle(Prs3d_Presentation)& aPresentation,
1395                                        const Handle(Prs3d_Drawer)& aDrawer,
1396                                        const TopoDS_Edge& anEdge,
1397                                        const Handle(Geom_Curve)& ProjCurve,
1398                                        const gp_Pnt& FirstP,
1399                                        const gp_Pnt& LastP,
1400                                        const Quantity_NameOfColor aColor,
1401                                        const Standard_Real aWidth,
1402                                        const Aspect_TypeOfLine aProjTOL,
1403                                        const Aspect_TypeOfLine aCallTOL)
1404 {
1405   if (!aDrawer->HasOwnWireAspect()){
1406     aDrawer->SetWireAspect(new Prs3d_LineAspect(aColor,aProjTOL,2.));}
1407   else {
1408     // CLE
1409     // const Handle(Prs3d_LineAspect)& li = aDrawer->WireAspect();
1410     Handle(Prs3d_LineAspect) li = aDrawer->WireAspect();
1411     // ENDCLE
1412     li->SetColor(aColor);
1413     li->SetTypeOfLine(aProjTOL);
1414     li->SetWidth(aWidth);
1415   }
1416
1417   Standard_Real pf, pl;
1418   TopLoc_Location loc;
1419   Handle(Geom_Curve) curve;
1420   Standard_Boolean isInfinite;
1421   curve = BRep_Tool::Curve(anEdge,loc,pf,pl);
1422   isInfinite = (Precision::IsInfinite(pf) || Precision::IsInfinite(pl));
1423
1424   TopoDS_Edge E;
1425
1426   // Calculate  presentation of the edge
1427   if (ProjCurve->IsInstance(STANDARD_TYPE(Geom_Line)) ) {
1428     // CLE
1429     // const Handle(Geom_Line) & gl = (Handle(Geom_Line)&) ProjCurve;
1430     Handle(Geom_Line) gl = (Handle(Geom_Line)&) ProjCurve;
1431     // ENDCLE
1432     if ( !isInfinite) {
1433       pf = ElCLib::Parameter(gl->Lin(),FirstP);
1434       pl = ElCLib::Parameter(gl->Lin(),LastP);
1435       BRepBuilderAPI_MakeEdge MakEd(gl->Lin(), pf, pl);
1436       E = MakEd.Edge();
1437     }
1438     else {
1439       BRepBuilderAPI_MakeEdge MakEd(gl->Lin());
1440       E = MakEd.Edge();
1441     }
1442   }
1443   else if (ProjCurve->IsInstance(STANDARD_TYPE(Geom_Circle)) ) {
1444     // CLE
1445     // const Handle(Geom_Circle) & gc = (Handle(Geom_Circle)&) ProjCurve;
1446     Handle(Geom_Circle) gc = (Handle(Geom_Circle)&) ProjCurve;
1447     // ENDCLE
1448     pf = ElCLib::Parameter(gc->Circ(),FirstP);
1449     pl = ElCLib::Parameter(gc->Circ(),LastP);
1450     BRepBuilderAPI_MakeEdge MakEd(gc->Circ(),pf, pl);
1451     E = MakEd.Edge();
1452   }
1453   StdPrs_WFDeflectionShape::Add(aPresentation, E, aDrawer);
1454
1455   //Calculate the presentation of line connections
1456   aDrawer->WireAspect()->SetTypeOfLine(aCallTOL);
1457   if (!isInfinite) {
1458     gp_Pnt ppf(0.0,0.0,0.0), ppl(0.0,0.0,0.0);
1459     ppf = BRep_Tool::Pnt( TopExp::FirstVertex(TopoDS::Edge(anEdge)));
1460     ppl = BRep_Tool::Pnt( TopExp::LastVertex(TopoDS::Edge(anEdge)));
1461
1462     // it is patch!
1463     if (FirstP.SquareDistance( ppf ) > SquareTolerance)
1464       {
1465         BRepBuilderAPI_MakeEdge MakEd1(FirstP, ppf);
1466         StdPrs_WFDeflectionShape::Add(aPresentation, MakEd1.Edge(), aDrawer);
1467       }
1468     else
1469       {
1470         BRepBuilderAPI_MakeVertex MakVert1( FirstP );
1471         StdPrs_WFDeflectionShape::Add(aPresentation, MakVert1.Vertex(), aDrawer);
1472       }
1473     if (LastP.SquareDistance( ppl ) > SquareTolerance)
1474       {
1475         BRepBuilderAPI_MakeEdge MakEd2(LastP, ppl);
1476         StdPrs_WFDeflectionShape::Add(aPresentation, MakEd2.Edge(), aDrawer);
1477       }
1478     else
1479       {
1480         BRepBuilderAPI_MakeVertex MakVert2( LastP );
1481         StdPrs_WFDeflectionShape::Add(aPresentation, MakVert2.Vertex(), aDrawer);
1482       }
1483 /*
1484     BRepBuilderAPI_MakeEdge MakEd1(FirstP, ppf);
1485     StdPrs_WFDeflectionShape::Add(aPresentation, MakEd1.Edge(), aDrawer);
1486     BRepBuilderAPI_MakeEdge MakEd2(LastP, ppl);
1487     StdPrs_WFDeflectionShape::Add(aPresentation, MakEd2.Edge(), aDrawer);
1488 */
1489   }
1490 }
1491
1492 //=======================================================================
1493 //function : ComputeProjVertexPresentation
1494 //purpose  : 
1495 //=======================================================================
1496
1497 void AIS::ComputeProjVertexPresentation (const Handle( Prs3d_Presentation )& aPresentation,
1498                                          const Handle( Prs3d_Drawer )& aDrawer,
1499                                          const TopoDS_Vertex& aVertex,
1500                                          const gp_Pnt& ProjPoint,
1501                                          const Quantity_NameOfColor aColor,
1502                                          const Standard_Real aWidth,
1503                                          const Aspect_TypeOfMarker aProjTOM,
1504                                          const Aspect_TypeOfLine aCallTOL)
1505 {
1506   if (!aDrawer->HasOwnPointAspect()){
1507     aDrawer->SetPointAspect(new Prs3d_PointAspect(aProjTOM, aColor,1));}
1508   else {
1509     // CLE
1510     // const Handle(Prs3d_PointAspect)& pa = aDrawer->PointAspect();
1511     Handle(Prs3d_PointAspect) pa = aDrawer->PointAspect();
1512     // ENDCLE
1513     pa->SetColor(aColor);
1514     pa->SetTypeOfMarker(aProjTOM);
1515   }
1516   
1517   // calculate the projection
1518   StdPrs_Point::Add(aPresentation, new Geom_CartesianPoint(ProjPoint), aDrawer);
1519
1520   if (!aDrawer->HasOwnWireAspect()){
1521     aDrawer->SetWireAspect(new Prs3d_LineAspect(aColor,aCallTOL,2.));}
1522   else {
1523     // CLE
1524     // const Handle(Prs3d_LineAspect)& li = aDrawer->WireAspect();
1525     Handle(Prs3d_LineAspect) li = aDrawer->WireAspect();
1526     // ENDCLE
1527     li->SetColor(aColor);
1528     li->SetTypeOfLine(aCallTOL);
1529     li->SetWidth(aWidth);
1530   }
1531   
1532   // If the points are not mixed...
1533   if (!ProjPoint.IsEqual (BRep_Tool::Pnt(aVertex),Precision::Confusion())) {
1534     // calculate the lines of recall
1535     BRepBuilderAPI_MakeEdge MakEd(ProjPoint,BRep_Tool::Pnt(aVertex));
1536     StdPrs_WFDeflectionShape::Add(aPresentation, MakEd.Edge(), aDrawer);
1537   }
1538 }