0024428: Implementation of LGPL license
[occt.git] / src / AIS / AIS_MidPointRelation.cxx
1 // Created on: 2000-10-20
2 // Created by: Julia DOROVSKIKH
3 // Copyright (c) 2000-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and / or modify it
8 // under the terms of the GNU Lesser General Public version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <AIS_MidPointRelation.ixx>
17
18 #include <Standard_NotImplemented.hxx>
19
20 #include <Precision.hxx>
21
22 #include <AIS.hxx>
23 #include <AIS_Drawer.hxx>
24
25 #include <gce_MakeLin.hxx>
26 #include <ElCLib.hxx>
27 #include <gp_Lin.hxx>
28 #include <gp_Circ.hxx>
29 #include <gp_Pnt.hxx>
30 #include <gp_Pln.hxx>
31 #include <gp_Dir.hxx>
32 #include <gp_Ax1.hxx>
33 #include <gp_Ax2.hxx>
34
35 #include <Geom_Plane.hxx>
36 #include <Geom_Line.hxx>
37 #include <Geom_Circle.hxx>
38 #include <Geom_Ellipse.hxx>
39 #include <Geom_TrimmedCurve.hxx>
40
41 #include <SelectMgr_EntityOwner.hxx>
42 #include <Select3D_SensitiveSegment.hxx>
43 #include <Select3D_SensitiveCurve.hxx>
44
45 #include <TopoDS.hxx>
46 #include <TopExp_Explorer.hxx>
47 #include <BRep_Tool.hxx>
48 #include <BRepAdaptor_Surface.hxx>
49 #include <BRepAdaptor_Curve.hxx>
50
51 #include <Prs3d_Drawer.hxx>
52 #include <Prs3d_ArrowAspect.hxx>
53 #include <Prs3d_DimensionAspect.hxx>
54
55 #include <DsgPrs_MidPointPresentation.hxx>
56 #include <TopoDS_Vertex.hxx>
57
58 //=======================================================================
59 //function : AIS_MidPointRelation
60 //purpose  : 
61 //=======================================================================
62 AIS_MidPointRelation::AIS_MidPointRelation(const TopoDS_Shape& aMidPointTool, 
63                                            const TopoDS_Shape& FirstShape, 
64                                            const TopoDS_Shape& SecondShape, 
65                                            const Handle(Geom_Plane)& aPlane)
66 :AIS_Relation(),
67  myTool(aMidPointTool)
68 {
69  SetFirstShape(FirstShape);
70  SetSecondShape(SecondShape);
71  SetPlane(aPlane);
72  myPosition = aPlane->Pln().Location();
73 }
74
75 //=======================================================================
76 //function : Compute
77 //purpose  : 
78 //=======================================================================
79 void AIS_MidPointRelation::Compute(const Handle(PrsMgr_PresentationManager3d)&, 
80                                    const Handle(Prs3d_Presentation)& aprs, 
81                                    const Standard_Integer)
82 {
83   aprs->Clear();
84   
85   if (myTool.ShapeType() == TopAbs_VERTEX)
86     {
87       gp_Pnt pp;
88       Standard_Boolean isonplane;
89       if ( AIS::ComputeGeometry(TopoDS::Vertex(myTool),pp,myPlane,isonplane) )
90         {
91           if ( !isonplane ) ComputeProjVertexPresentation(aprs,TopoDS::Vertex(myTool),pp);
92         }
93       myMidPoint = pp;
94     }
95   else return;
96
97   if ( myAutomaticPosition ) myPosition = myMidPoint;  
98
99   switch (myFShape.ShapeType())
100     {
101     case TopAbs_FACE :
102       {
103         ComputeFaceFromPnt(aprs, Standard_True);
104       }
105       break;
106     case TopAbs_EDGE :
107       {
108         ComputeEdgeFromPnt(aprs, Standard_True);
109       }
110       break;
111     case TopAbs_VERTEX :
112       {
113         ComputeVertexFromPnt(aprs, Standard_True);
114       }
115       break;
116     default:
117       break;
118     }
119
120   switch (mySShape.ShapeType())
121     {
122     case TopAbs_FACE :
123       {
124         ComputeFaceFromPnt(aprs, Standard_False);
125       }
126       break;
127     case TopAbs_EDGE :
128       {
129         ComputeEdgeFromPnt(aprs, Standard_False);
130       }
131       break;
132     case TopAbs_VERTEX :
133       {
134         ComputeVertexFromPnt(aprs, Standard_False);
135       }
136       break;
137     default:
138       break;
139     }
140 }
141
142 //=======================================================================
143 //function : Compute
144 //purpose  : to avoid warning at compilation (SUN)
145 //=======================================================================
146 void AIS_MidPointRelation::Compute(const Handle(Prs3d_Projector)& /*aProjector*/,
147                                    const Handle(Prs3d_Presentation)& /*aPresentation*/)
148 {
149 // Standard_NotImplemented::Raise("AIS_MidPointRelation::Compute(const Handle(Prs3d_Projector)&,const Handle(Prs3d_Presentation)&)");
150 // PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
151 }
152
153 void AIS_MidPointRelation::Compute(const Handle_Prs3d_Projector& aProjector,
154                                    const Handle_Geom_Transformation& aTransformation,
155                                    const Handle_Prs3d_Presentation& aPresentation)
156 {
157  Standard_NotImplemented::Raise("AIS_MidPointRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
158  PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
159 }
160
161 //=======================================================================
162 //function : ComputeSelection
163 //purpose  : 
164 //=======================================================================
165 void AIS_MidPointRelation::ComputeSelection(const Handle(SelectMgr_Selection)& aSel, 
166                                             const Standard_Integer)
167 {
168   Handle(Select3D_SensitiveSegment) seg;
169   Handle(SelectMgr_EntityOwner) own = new SelectMgr_EntityOwner(this,7);
170
171   if ( !myMidPoint.IsEqual(myFAttach,Precision::Confusion()) )
172     {
173       // segment from mid point to the first geometry
174       seg = new Select3D_SensitiveSegment(own,myFAttach,myMidPoint);
175       aSel->Add(seg);
176       // segment from mid point to the second geometry
177       seg = new Select3D_SensitiveSegment(own,mySAttach,myMidPoint);
178       aSel->Add(seg);
179     }
180   if ( !myMidPoint.IsEqual(myPosition,Precision::Confusion()) )
181     {
182       // segment from mid point to the text position
183       seg = new Select3D_SensitiveSegment(own,myMidPoint,myPosition);
184       aSel->Add(seg);
185     }
186
187   // center of the symmetry - circle around the MidPoint
188   gp_Ax2 ax = myPlane->Pln().Position().Ax2();
189   ax.SetLocation(myMidPoint);
190   Standard_Real rad = myFAttach.Distance(myMidPoint)/20.0;
191   gp_Circ aCircleM (ax,rad);
192   Handle(Geom_Circle) thecir = new Geom_Circle(aCircleM);
193   Handle(Select3D_SensitiveCurve) scurv = new Select3D_SensitiveCurve(own, thecir);
194   aSel->Add(scurv);
195
196   Handle(Geom_Curve) curv;
197   gp_Pnt firstp,lastp;
198   Standard_Boolean isInfinite,isOnPlane;
199   Handle(Geom_Curve) extCurv;
200
201   // segment on first curve
202   if ( myFShape.ShapeType() == TopAbs_EDGE )
203     {
204       TopoDS_Edge E = TopoDS::Edge(myFShape);
205       if ( !AIS::ComputeGeometry(E,curv,firstp,lastp,extCurv,isInfinite,isOnPlane,myPlane) ) return;
206       if ( curv->IsInstance(STANDARD_TYPE(Geom_Line)) ) // case of line
207         {
208           // segment on line
209           seg = new Select3D_SensitiveSegment(own,myFirstPnt1,myFirstPnt2);
210           aSel->Add(seg);
211         }
212       else if ( curv->IsInstance(STANDARD_TYPE(Geom_Circle)) ) // case of circle
213         {
214           // segment on circle
215           Handle(Geom_Circle) thecirc = (Handle(Geom_Circle)&) curv;
216           Standard_Real udeb = ElCLib::Parameter(thecirc->Circ(),myFirstPnt1);
217           Standard_Real ufin = ElCLib::Parameter(thecirc->Circ(),myFirstPnt2);
218           Handle(Geom_TrimmedCurve) thecu = new Geom_TrimmedCurve(thecirc,udeb,ufin);
219           
220           scurv = new Select3D_SensitiveCurve(own, thecu);
221           aSel->Add(scurv);
222         }
223       else if ( curv->IsInstance(STANDARD_TYPE(Geom_Ellipse)) ) // case of ellipse
224         {
225           // segment on ellipse
226           Handle(Geom_Ellipse) theEll = (Handle(Geom_Ellipse)&) curv;
227           Standard_Real udeb = ElCLib::Parameter(theEll->Elips(),myFirstPnt1);
228           Standard_Real ufin = ElCLib::Parameter(theEll->Elips(),myFirstPnt2);
229           Handle(Geom_TrimmedCurve) thecu = new Geom_TrimmedCurve(theEll,udeb,ufin);
230           
231           scurv = new Select3D_SensitiveCurve(own, thecu);
232           aSel->Add(scurv);
233         }
234     }
235
236   // segment on second curve
237   if ( mySShape.ShapeType() == TopAbs_EDGE )
238     {
239       TopoDS_Edge E = TopoDS::Edge(mySShape);
240       if ( !AIS::ComputeGeometry(E,curv,firstp,lastp,extCurv,isInfinite,isOnPlane,myPlane) ) return;
241       if ( curv->IsInstance(STANDARD_TYPE(Geom_Line)) ) // case of line
242         {
243           // segment on line
244           seg = new Select3D_SensitiveSegment(own,mySecondPnt1,mySecondPnt2);
245           aSel->Add(seg);
246         }
247       else if ( curv->IsInstance(STANDARD_TYPE(Geom_Circle)) ) // case of circle
248         {
249           // segment on circle
250           Handle(Geom_Circle) thecirc = (Handle(Geom_Circle)&) curv;
251           Standard_Real udeb = ElCLib::Parameter(thecirc->Circ(),mySecondPnt1);
252           Standard_Real ufin = ElCLib::Parameter(thecirc->Circ(),mySecondPnt2);
253           Handle(Geom_TrimmedCurve) thecu = new Geom_TrimmedCurve(thecirc,udeb,ufin);
254           
255           scurv = new Select3D_SensitiveCurve(own, thecu);
256           aSel->Add(scurv);
257         }
258       else if ( curv->IsInstance(STANDARD_TYPE(Geom_Ellipse)) ) // case of ellipse
259         {
260           // segment on ellipse
261           Handle(Geom_Ellipse) theEll = (Handle(Geom_Ellipse)&) curv;
262           Standard_Real udeb = ElCLib::Parameter(theEll->Elips(),mySecondPnt1);
263           Standard_Real ufin = ElCLib::Parameter(theEll->Elips(),mySecondPnt2);
264           Handle(Geom_TrimmedCurve) thecu = new Geom_TrimmedCurve(theEll,udeb,ufin);
265           
266           scurv = new Select3D_SensitiveCurve(own, thecu);
267           aSel->Add(scurv);
268         }
269     }
270 }
271
272 //=======================================================================
273 //function : ComputeFaceFromPnt
274 //purpose  : 
275 //=======================================================================
276 void AIS_MidPointRelation::ComputeFaceFromPnt(const Handle(Prs3d_Presentation)&,
277                                               const Standard_Boolean /*first*/)
278 {
279 }
280
281 //=======================================================================
282 //function : ComputeEdgeFromPnt
283 //purpose  : 
284 //=======================================================================
285 void AIS_MidPointRelation::ComputeEdgeFromPnt(const Handle(Prs3d_Presentation)& aprs,
286                                               const Standard_Boolean first)
287 {
288   TopoDS_Edge E;
289   if ( first ) E = TopoDS::Edge(myFShape);
290   else         E = TopoDS::Edge(mySShape);
291
292   Handle(Geom_Curve) geom;
293   gp_Pnt ptat1,ptat2;
294   Handle(Geom_Curve) extCurv;
295   Standard_Boolean isInfinite,isOnPlane;
296   if ( !AIS::ComputeGeometry(E, geom, ptat1, ptat2, extCurv, isInfinite, isOnPlane, myPlane) ) return;
297
298   gp_Ax2 ax = myPlane->Pln().Position().Ax2();
299
300   if ( geom->IsInstance(STANDARD_TYPE(Geom_Line)) )
301     {
302       if ( !isInfinite ) ComputePointsOnLine(ptat1,ptat2,first);
303       else
304         {
305           const gp_Lin& line = ((Handle(Geom_Line)&) geom)->Lin();
306           ComputePointsOnLine(line,first);
307         }
308       if ( first ) DsgPrs_MidPointPresentation::Add(aprs,myDrawer,ax,myMidPoint,myPosition,
309                                                     myFAttach,myFirstPnt1,myFirstPnt2,first);
310       else         DsgPrs_MidPointPresentation::Add(aprs,myDrawer,ax,myMidPoint,myPosition,
311                                                     mySAttach,mySecondPnt1,mySecondPnt2,first);
312     }
313   else if ( geom->IsInstance(STANDARD_TYPE(Geom_Circle)) )
314     {
315       const Handle(Geom_Circle)& geom_cir = (Handle(Geom_Circle)&) geom;
316       gp_Circ circ (geom_cir->Circ());
317       ComputePointsOnCirc(circ,ptat1,ptat2,first);
318       if ( first ) DsgPrs_MidPointPresentation::Add(aprs,myDrawer,circ,myMidPoint,myPosition,
319                                                     myFAttach,myFirstPnt1,myFirstPnt2,first);
320       else         DsgPrs_MidPointPresentation::Add(aprs,myDrawer,circ,myMidPoint,myPosition,
321                                                     mySAttach,mySecondPnt1,mySecondPnt2,first);
322     }
323   else if ( geom->IsInstance(STANDARD_TYPE(Geom_Ellipse)) )
324     {
325       const Handle(Geom_Ellipse)& geom_ell = (Handle(Geom_Ellipse)&) geom;
326       gp_Elips elips (geom_ell->Elips());
327       ComputePointsOnElips(elips,ptat1,ptat2,first);
328       if ( first ) DsgPrs_MidPointPresentation::Add(aprs,myDrawer,elips,myMidPoint,myPosition,
329                                                     myFAttach,myFirstPnt1,myFirstPnt2,first);
330       else         DsgPrs_MidPointPresentation::Add(aprs,myDrawer,elips,myMidPoint,myPosition,
331                                                     mySAttach,mySecondPnt1,mySecondPnt2,first);
332     }
333   else return;
334
335   // projection on myPlane
336   if ( !isOnPlane ) ComputeProjEdgePresentation(aprs,E,geom,ptat1,ptat2);
337 }
338
339 //=======================================================================
340 //function : ComputeVertexFromPnt
341 //purpose  : 
342 //=======================================================================
343 void AIS_MidPointRelation::ComputeVertexFromPnt(const Handle(Prs3d_Presentation)& aprs,
344                                                 const Standard_Boolean first)
345 {
346   gp_Ax2 ax = myPlane->Pln().Position().Ax2();
347   if ( first )
348     {
349       Standard_Boolean isOnPlane;
350       TopoDS_Vertex V = TopoDS::Vertex(myFShape);
351       AIS::ComputeGeometry(V, myFAttach, myPlane, isOnPlane);
352       DsgPrs_MidPointPresentation::Add(aprs,myDrawer,ax,myMidPoint,myPosition,myFAttach,first);
353       if ( !isOnPlane ) ComputeProjVertexPresentation(aprs,V,myFAttach);
354     }
355   else
356     {
357       Standard_Boolean isOnPlane;
358       TopoDS_Vertex V = TopoDS::Vertex(mySShape);
359       AIS::ComputeGeometry(V, mySAttach, myPlane, isOnPlane);
360       DsgPrs_MidPointPresentation::Add(aprs,myDrawer,ax,myMidPoint,myPosition,mySAttach,first);
361       if ( !isOnPlane ) ComputeProjVertexPresentation(aprs,V,mySAttach);
362     }
363 }
364
365 //=======================================================================
366 //function : ComputePointsOnLine
367 //purpose  : 
368 //=======================================================================
369 void AIS_MidPointRelation::ComputePointsOnLine(const gp_Lin& aLin,
370                                                const Standard_Boolean first)
371 {
372   Standard_Real ppar = ElCLib::Parameter(aLin,myMidPoint);
373   gp_Pnt anAttach = ElCLib::Value(ppar,aLin);
374
375   Standard_Real dist = anAttach.Distance(myMidPoint)/10.0;
376   if ( dist < Precision::Confusion() ) dist = 10.0;
377
378   Standard_Real fpar = ppar + dist;
379   Standard_Real spar = ppar - dist;
380
381   gp_Pnt aPnt1 = ElCLib::Value(fpar,aLin);
382   gp_Pnt aPnt2 = ElCLib::Value(spar,aLin);
383
384   if ( first )
385     {
386       myFAttach = anAttach;
387       myFirstPnt1 = aPnt1;
388       myFirstPnt2 = aPnt2;
389     }
390   else
391     {
392       mySAttach = anAttach;
393       mySecondPnt1 = aPnt1;
394       mySecondPnt2 = aPnt2;
395     }
396 }
397
398 //=======================================================================
399 //function : ComputePointsOnLine
400 //purpose  : 
401 //=======================================================================
402 void AIS_MidPointRelation::ComputePointsOnLine(const gp_Pnt& pnt1, const gp_Pnt& pnt2,
403                                                const Standard_Boolean first)
404 {
405   gp_Vec aVec (pnt1,pnt2);
406   gp_Lin aLin (pnt1,gp_Dir(aVec));
407
408   Standard_Real fpar = ElCLib::Parameter(aLin,pnt1);
409   Standard_Real spar = ElCLib::Parameter(aLin,pnt2);
410   Standard_Real ppar = ElCLib::Parameter(aLin,myMidPoint);
411
412   gp_Pnt aProjPnt = ElCLib::Value(ppar,aLin);
413   Standard_Real dist = myMidPoint.Distance(aProjPnt);
414   Standard_Real ll = pnt1.Distance(pnt2);
415   Standard_Real segm = Min(dist,ll)*0.75;
416   if ( dist < Precision::Confusion() ) segm = ll*0.75;
417
418   gp_Pnt anAttach,aPnt1,aPnt2;
419   anAttach = aProjPnt;
420   gp_Vec aVecTr;
421   if ( ppar <= fpar )
422     {
423       aPnt2 = pnt1;
424       aVecTr = gp_Vec(pnt2,pnt1);
425       aVecTr.Normalize();
426       aPnt1 = aProjPnt.Translated(aVecTr*segm);
427     }
428   else if ( ppar >= spar )
429     {
430       aPnt1 = pnt2;
431       aVecTr = gp_Vec(pnt1,pnt2);
432       aVecTr.Normalize();
433       aPnt2 = aProjPnt.Translated(aVecTr*segm);
434     }
435   else
436     {
437       Standard_Real dp1 = aProjPnt.Distance(pnt1);
438       Standard_Real dp2 = aProjPnt.Distance(pnt2);
439
440       segm = Min(dist,dp1)*0.75;
441       aVecTr = gp_Vec(aProjPnt,pnt1);
442       aVecTr.Normalize();
443       aPnt1 = aProjPnt.Translated(aVecTr*segm);
444
445       segm = Min(dist,dp2)*0.75;
446       aVecTr = gp_Vec(aProjPnt,pnt2);
447       aVecTr.Normalize();
448       aPnt2 = aProjPnt.Translated(aVecTr*segm);
449     }
450
451   if ( first )
452     {
453       myFAttach = anAttach;
454       myFirstPnt1 = aPnt1;
455       myFirstPnt2 = aPnt2;
456     }
457   else
458     {
459       mySAttach = anAttach;
460       mySecondPnt1 = aPnt1;
461       mySecondPnt2 = aPnt2;
462     }
463 }
464
465 //=======================================================================
466 //function : ComputePointsOnCirc
467 //purpose  : 
468 //=======================================================================
469 void AIS_MidPointRelation::ComputePointsOnCirc(const gp_Circ& aCirc,
470                                                const gp_Pnt& pnt1, const gp_Pnt& pnt2,
471                                                const Standard_Boolean first)
472 {
473   gp_Pnt curpos = myMidPoint;
474
475   // Case of confusion between the current position and the center 
476   // of the circle -> we move the current position
477   Standard_Real confusion (Precision::Confusion());
478   gp_Pnt aCenter = aCirc.Location();
479   if ( aCenter.Distance(curpos) <= confusion )
480     {
481       gp_Vec vprec(aCenter, pnt1);
482       vprec.Normalize();
483       curpos.Translate(vprec*1e-5);
484     }
485   
486   Standard_Real pcurpos = ElCLib::Parameter(aCirc,curpos);
487
488   Standard_Real rad = M_PI / 5.0;
489   Standard_Real segm;
490
491   Standard_Real pFPnt;
492   Standard_Real pSPnt;
493
494   if ( pnt1.IsEqual(pnt2,confusion) ) // full circle
495     {
496       pFPnt = pcurpos - rad;
497       pSPnt = pcurpos + rad;
498     }
499   else
500     {
501       Standard_Real pFAttach = ElCLib::Parameter(aCirc,pnt1);
502       Standard_Real pSAttach = ElCLib::Parameter(aCirc,pnt2);
503
504       Standard_Real pSAttachM = pSAttach;
505       Standard_Real deltap = pSAttachM - pFAttach;
506       if ( deltap < 0 )
507         {
508           deltap += 2 * M_PI;
509           pSAttachM += 2 * M_PI;
510         }
511       pSAttachM -= pFAttach;
512
513       Standard_Real pmiddleout = pSAttachM/2.0 + M_PI;
514
515       Standard_Real pcurpos1 = pcurpos;
516       // define where curpos lays
517       if ( pcurpos1 < pFAttach )
518         {
519           pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
520           if ( pcurpos1 > pSAttachM ) // out
521             {
522               segm = Min(rad,deltap*0.75);
523               if ( pcurpos1 > pmiddleout )
524                 {
525                   pcurpos = pFAttach;
526                   pFPnt = pFAttach;
527                   pSPnt = pFAttach + segm;
528                 }
529               else
530                 {
531                   pcurpos = pSAttach;
532                   pFPnt = pSAttach - segm;
533                   pSPnt = pSAttach;
534                 }
535             }
536           else // on arc
537             {
538               Standard_Real dp1 = pcurpos1 - pFAttach;
539               Standard_Real dp2 = pSAttachM - pcurpos1;
540
541               segm = Min(rad,dp1*0.75);
542               pFPnt = pcurpos - segm;
543               
544               segm = Min(rad,dp2*0.75);
545               pSPnt = pcurpos + segm;
546             }
547         }
548       else if ( pcurpos1 > (pFAttach + deltap) ) // out
549         {
550           pcurpos1 -= pFAttach;
551           segm = Min(rad,deltap*0.75);
552           if ( pcurpos1 > pmiddleout )
553             {
554               pcurpos = pFAttach;
555               pFPnt = pFAttach;
556               pSPnt = pFAttach + segm;
557             }
558           else
559             {
560               pcurpos = pSAttach;
561               pFPnt = pSAttach - segm;
562               pSPnt = pSAttach;
563             }
564         }
565       else // on arc
566         {
567           Standard_Real dp1 = pcurpos1 - pFAttach;
568           Standard_Real dp2 = pSAttach - pcurpos1;
569
570           segm = Min(rad,dp1*0.75);
571           pFPnt = pcurpos - segm;
572           
573           segm = Min(rad,dp2*0.75);
574           pSPnt = pcurpos + segm;
575         }
576     }
577
578   if ( first )
579     {
580       myFAttach   = ElCLib::Value(pcurpos,aCirc);
581       myFirstPnt1 = ElCLib::Value(pFPnt,aCirc);
582       myFirstPnt2 = ElCLib::Value(pSPnt,aCirc);
583     }
584   else
585     {
586       mySAttach    = ElCLib::Value(pcurpos,aCirc);
587       mySecondPnt1 = ElCLib::Value(pFPnt,aCirc);
588       mySecondPnt2 = ElCLib::Value(pSPnt,aCirc);
589     }
590 }
591
592 //=======================================================================
593 //function : ComputePointsOnElips
594 //purpose  : 
595 //=======================================================================
596 void AIS_MidPointRelation::ComputePointsOnElips(const gp_Elips& anEll,
597                                                 const gp_Pnt& pnt1, const gp_Pnt& pnt2,
598                                                 const Standard_Boolean first)
599 {
600   gp_Pnt curpos = myMidPoint;
601
602   // Case of confusion between the current position and the center 
603   // of the circle -> we move the current position
604   Standard_Real confusion (Precision::Confusion());
605   gp_Pnt aCenter = anEll.Location();
606   if ( aCenter.Distance(curpos) <= confusion )
607     {
608       gp_Vec vprec(aCenter, pnt1);
609       vprec.Normalize();
610       curpos.Translate(vprec*1e-5);
611     }
612   
613   Standard_Real pcurpos = ElCLib::Parameter(anEll,curpos);
614
615   Standard_Real rad = M_PI / 5.0;
616   Standard_Real segm;
617
618   Standard_Real pFPnt;
619   Standard_Real pSPnt;
620
621   if ( pnt1.IsEqual(pnt2,confusion) ) // full circle
622     {
623       pFPnt = pcurpos - rad;
624       pSPnt = pcurpos + rad;
625     }
626   else
627     {
628       Standard_Real pFAttach = ElCLib::Parameter(anEll,pnt1);
629       Standard_Real pSAttach = ElCLib::Parameter(anEll,pnt2);
630
631       Standard_Real pSAttachM = pSAttach;
632       Standard_Real deltap = pSAttachM - pFAttach;
633       if ( deltap < 0 )
634         {
635           deltap += 2 * M_PI;
636           pSAttachM += 2 * M_PI;
637         }
638       pSAttachM -= pFAttach;
639
640       Standard_Real pmiddleout = pSAttachM / 2.0 + M_PI;
641
642       Standard_Real pcurpos1 = pcurpos;
643       // define where curpos lays
644       if ( pcurpos1 < pFAttach )
645         {
646           pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
647           if ( pcurpos1 > pSAttachM ) // out
648             {
649               segm = Min(rad,deltap*0.75);
650               if ( pcurpos1 > pmiddleout )
651                 {
652                   pcurpos = pFAttach;
653                   pFPnt = pFAttach;
654                   pSPnt = pFAttach + segm;
655                 }
656               else
657                 {
658                   pcurpos = pSAttach;
659                   pFPnt = pSAttach - segm;
660                   pSPnt = pSAttach;
661                 }
662             }
663           else // on arc
664             {
665               Standard_Real dp1 = pcurpos1 - pFAttach;
666               Standard_Real dp2 = pSAttachM - pcurpos1;
667
668               segm = Min(rad,dp1*0.75);
669               pFPnt = pcurpos - segm;
670               
671               segm = Min(rad,dp2*0.75);
672               pSPnt = pcurpos + segm;
673             }
674         }
675       else if ( pcurpos1 > (pFAttach + deltap) ) // out
676         {
677           pcurpos1 -= pFAttach;
678           segm = Min(rad,deltap*0.75);
679           if ( pcurpos1 > pmiddleout )
680             {
681               pcurpos = pFAttach;
682               pFPnt = pFAttach;
683               pSPnt = pFAttach + segm;
684             }
685           else
686             {
687               pcurpos = pSAttach;
688               pFPnt = pSAttach - segm;
689               pSPnt = pSAttach;
690             }
691         }
692       else // on arc
693         {
694           Standard_Real dp1 = pcurpos1 - pFAttach;
695           Standard_Real dp2 = pSAttach - pcurpos1;
696
697           segm = Min(rad,dp1*0.75);
698           pFPnt = pcurpos - segm;
699           
700           segm = Min(rad,dp2*0.75);
701           pSPnt = pcurpos + segm;
702         }
703     }
704
705   if ( first )
706     {
707       myFAttach   = ElCLib::Value(pcurpos,anEll);
708       myFirstPnt1 = ElCLib::Value(pFPnt,anEll);
709       myFirstPnt2 = ElCLib::Value(pSPnt,anEll);
710     }
711   else
712     {
713       mySAttach    = ElCLib::Value(pcurpos,anEll);
714       mySecondPnt1 = ElCLib::Value(pFPnt,anEll);
715       mySecondPnt2 = ElCLib::Value(pSPnt,anEll);
716     }
717 }