0029987: Request for translation of French comments in the code
[occt.git] / src / TPrsStd / TPrsStd_ConstraintTools.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 // Language:    C++
15 // Version:     Euclid Designer 2.0
16 // Purpose:     Update AIS object from a TDataXtd_Constraint.
17 // Modified     Mon 30 10:15:43 1998 by SZY
18
19 #include <AIS_AngleDimension.hxx>
20 #include <AIS_ConcentricRelation.hxx>
21 #include <AIS_DiameterDimension.hxx>
22 #include <AIS_EqualDistanceRelation.hxx>
23 #include <AIS_EqualRadiusRelation.hxx>
24 #include <AIS_FixRelation.hxx>
25 #include <AIS_IdenticRelation.hxx>
26 #include <AIS_InteractiveContext.hxx>
27 #include <AIS_InteractiveObject.hxx>
28 #include <AIS_LengthDimension.hxx>
29 #include <AIS_MaxRadiusDimension.hxx>
30 #include <AIS_MidPointRelation.hxx>
31 #include <AIS_MinRadiusDimension.hxx>
32 #include <AIS_OffsetDimension.hxx>
33 #include <AIS_ParallelRelation.hxx>
34 #include <AIS_PerpendicularRelation.hxx>
35 #include <AIS_RadiusDimension.hxx>
36 #include <AIS_Relation.hxx>
37 #include <AIS_SymmetricRelation.hxx>
38 #include <AIS_TangentRelation.hxx>
39 #include <BRep_Builder.hxx>
40 #include <BRep_Tool.hxx>
41 #include <BRepAdaptor_Curve.hxx>
42 #include <BRepAdaptor_Surface.hxx>
43 #include <BRepBuilderAPI_MakeFace.hxx>
44 #include <GC_MakePlane.hxx>
45 #include <Geom_CartesianPoint.hxx>
46 #include <Geom_Circle.hxx>
47 #include <Geom_Geometry.hxx>
48 #include <Geom_Line.hxx>
49 #include <Geom_Plane.hxx>
50 #include <GeomAbs_SurfaceType.hxx>
51 #include <gp_Ax1.hxx>
52 #include <gp_Cone.hxx>
53 #include <gp_Cylinder.hxx>
54 #include <gp_Dir.hxx>
55 #include <gp_Lin.hxx>
56 #include <gp_Pln.hxx>
57 #include <gp_Pnt.hxx>
58 #include <gp_Torus.hxx>
59 #include <IntAna_QuadQuadGeo.hxx>
60 #include <Precision.hxx>
61 #include <Prs3d_Drawer.hxx>
62 #include <Standard_ErrorHandler.hxx>
63 #include <Standard_ProgramError.hxx>
64 #include <TCollection_ExtendedString.hxx>
65 #include <TDataStd_Name.hxx>
66 #include <TDataStd_Real.hxx>
67 #include <TDataXtd_Constraint.hxx>
68 #include <TDataXtd_Geometry.hxx>
69 #include <TDF_Label.hxx>
70 #include <TDF_Reference.hxx>
71 #include <TNaming_Iterator.hxx>
72 #include <TNaming_NamedShape.hxx>
73 #include <TNaming_Tool.hxx>
74 #include <TopExp.hxx>
75 #include <TopExp_Explorer.hxx>
76 #include <TopoDS.hxx>
77 #include <TopoDS_Edge.hxx>
78 #include <TopoDS_Face.hxx>
79 #include <TopoDS_Shape.hxx>
80 #include <TopoDS_Vertex.hxx>
81 #include <TopTools_IndexedMapOfShape.hxx>
82 #include <TPrsStd_ConstraintTools.hxx>
83 #include <UnitsAPI.hxx>
84
85 #include <stdio.h>
86 static Standard_Boolean CheckShapesPair(const TopoDS_Shape& , const TopoDS_Shape& ); //ota
87
88 //=======================================================================
89 //function : static NullifyAIS
90 //purpose  : 
91 //=======================================================================
92 static void NullifyAIS ( Handle(AIS_InteractiveObject)& anais)
93 {
94   if (anais.IsNull())  return;
95   anais.Nullify();
96 }
97
98
99
100 //=======================================================================
101 //function : static FindExternalShape
102 //purpose  : 
103 //=======================================================================
104 static void FindExternalShape(const Handle(TDataXtd_Constraint)& aConst,
105                               Standard_Integer& extShape)
106 {
107   extShape = 0;
108     const TDF_Label& L =  aConst->Label();
109     if (!aConst->GetGeometry(1)->Label().IsDescendant(L)) extShape = 1;    
110     else if (!aConst->GetGeometry(2)->Label().IsDescendant(L)) extShape = 2;
111 }
112
113 //=======================================================================
114 //function : static GetGoodShape for planar constraint
115 //purpose  : 
116 //=======================================================================
117 static void  GetGoodShape(TopoDS_Shape& theShape)
118 {
119   switch (theShape.ShapeType())
120   {
121   case TopAbs_EDGE:
122   case TopAbs_VERTEX: { return; }
123   default:
124     {
125       TopExp_Explorer anExp (theShape,TopAbs_EDGE);
126       if (anExp.More())
127       {
128         theShape = anExp.Current();
129         return;
130       }
131       else
132       {
133         anExp.Init (theShape, TopAbs_VERTEX);
134         if (anExp.More())
135         {
136           theShape = anExp.Current();
137         }
138       }
139     }
140   }
141 }
142
143 // Pour le cas ou S est un compound
144 static Standard_Boolean IsFace (const TopoDS_Shape& S)
145 {
146   Standard_Boolean  findface = Standard_False;
147   TopExp_Explorer EXP (S,TopAbs_FACE);
148   if (EXP.More()) findface = Standard_True;
149   return  findface;
150 }
151
152 static TopoDS_Face  GetFace (const TopoDS_Shape& S)
153 {
154   TopoDS_Face F;
155   TopExp_Explorer EXP (S,TopAbs_FACE);
156   if (EXP.More())  F = TopoDS::Face (EXP.Current());
157   return  F;
158 }
159
160 static TopoDS_Edge  GetEdge (const TopoDS_Shape& S)
161 {
162   TopoDS_Edge E;
163   TopExp_Explorer EXP (S, TopAbs_EDGE);
164   if (EXP.More()) E = TopoDS::Edge (EXP.Current());
165   return  E;
166 }
167
168
169
170 //=======================================================================
171 //Function : ComputeAndTextValue
172 //purpose  : 
173 //=======================================================================
174 void TPrsStd_ConstraintTools::ComputeTextAndValue(const Handle(TDataXtd_Constraint)& aConst,
175                                                  Standard_Real&                val,
176                                                  TCollection_ExtendedString&   txt,
177                                                  const Standard_Boolean  anIsAngle  )
178 {
179   Standard_Real outvalue;
180   const Handle(TDataStd_Real)& VAL = aConst->GetValue();
181   val      = VAL->Get();
182   if(anIsAngle){
183     outvalue = UnitsAPI::CurrentFromLS(Abs(val),"PLANE ANGLE");
184   }
185   else {
186     outvalue = UnitsAPI::CurrentFromLS(val,"LENGTH");
187   }
188   char res[1000];
189   sprintf(res,"%g",outvalue);
190   txt = TCollection_ExtendedString(res);
191   
192   if (VAL->IsCaptured()) {
193     Handle(TDF_Reference) ref;
194     VAL->Label().FindAttribute(TDF_Reference::GetID(),ref);
195     Handle(TDataStd_Name) name;
196     const TDF_Label& L = ref->Get();
197     if (ref->Get().FindAttribute(TDataStd_Name::GetID(),name)) {
198       TCollection_ExtendedString fullname;
199       Handle(TDataStd_Name) Fathername;
200       if (L.Father().FindAttribute(TDataStd_Name::GetID(),Fathername)) {
201         fullname = Fathername->Get() + TCollection_ExtendedString(".") + name->Get();
202       }
203       else fullname = name->Get();
204       txt = fullname + TCollection_ExtendedString("=") + txt;
205     }
206   }
207 }
208
209
210 //=======================================================================
211 //function : UpdateOnlyValue
212 //purpose  : 
213 //=======================================================================
214
215 void TPrsStd_ConstraintTools::UpdateOnlyValue(const Handle(TDataXtd_Constraint)& aConst, 
216                                      const Handle(AIS_InteractiveObject)& anAIS)
217 {
218   if (anAIS.IsNull()) return; 
219   if (!aConst->IsDimension()) return; 
220   Standard_Real val;
221   TCollection_ExtendedString txt;
222   TPrsStd_ConstraintTools:: ComputeTextAndValue(aConst,val,txt,aConst->GetType() == TDataXtd_ANGLE);
223   Handle(AIS_Relation) rel = Handle(AIS_Relation)::DownCast(anAIS);
224   if (!rel.IsNull()) rel->SetText(txt); 
225 }
226
227
228 //=======================================================================
229 //function : ComputeDistance
230 //purpose  : Build an AIS_LengthDimension.
231 //=======================================================================
232 void TPrsStd_ConstraintTools::ComputeDistance (const Handle(TDataXtd_Constraint)& theConst,
233                                                Handle(AIS_InteractiveObject)&     theAIS)
234 {
235   Standard_Integer aGeomNum = theConst->NbGeometries();
236
237   // Dimension is build on one or two shapes.
238   if (aGeomNum < 1 || aGeomNum > 2)
239   {
240 #ifdef OCCT_DEBUG
241     cout <<  "TPrsStd_ConstraintTools::ComputeDistance: 1 or 2 geometries are needed" << endl;
242 #endif
243     NullifyAIS(theAIS);
244     return;
245   }
246
247   TopoDS_Shape aShape1, aShape2;
248   Handle(Geom_Geometry) aGeom3;
249   Standard_Boolean isPlanar (theConst->IsPlanar());
250
251   // Get shapes and geometry
252   if (aGeomNum == 1)
253   {
254     GetOneShape (theConst, aShape1);
255
256     if (aShape1.IsNull())
257     {
258       #ifdef OCCT_DEBUG
259       cout << "TPrsStd_ConstraintTools::ComputeDistance : null shape" << endl;
260       #endif
261       NullifyAIS (theAIS);
262       return;
263     }
264   }
265   else //aGeomNum == 2
266   {
267     GetTwoShapes (theConst, aShape1, aShape2);
268
269     if (aShape1.IsNull() || aShape2.IsNull())
270     {
271       #ifdef OCCT_DEBUG
272       cout << "TPrsStd_ConstraintTools::ComputeDistance : null shape" << endl;
273       #endif
274       NullifyAIS (theAIS);
275       return;
276     }
277   }
278
279   // Get plane from constraint
280   Handle(Geom_Plane) aPlane;
281   if (isPlanar)
282   {
283     GetGeom (theConst, aGeom3);
284
285     GetGoodShape (aShape1);
286
287     if (aGeomNum == 2)
288     {
289       GetGoodShape (aShape2);
290     }
291
292     aPlane = Handle(Geom_Plane)::DownCast (aGeom3);
293   }
294
295   // Get custom value
296   Standard_Real aValue;
297   TCollection_ExtendedString aText;
298   ComputeTextAndValue (theConst, aValue, aText,Standard_False);
299
300   Standard_Boolean isFaces     = Standard_False;
301   Standard_Boolean isEdges     = Standard_False;
302   Standard_Boolean isEdgeFace  = Standard_False;
303   Standard_Boolean isVertices  = Standard_False;
304   Standard_Boolean isEdge      = Standard_False;
305
306   Standard_Boolean SaveDrw = Standard_False;
307   Handle(Prs3d_Drawer) aDrawer;
308   Handle(AIS_LengthDimension) aDim;
309
310   if (!theAIS.IsNull())
311   {
312     aDim = Handle(AIS_LengthDimension)::DownCast (theAIS);
313   }
314
315   // Check shapes for AIS dimension
316   if (aGeomNum == 1)
317   {
318     if (aShape1.ShapeType () != TopAbs_EDGE)
319     {
320       #ifdef OCCT_DEBUG
321       cout << "TPrsStd_ConstraintTools::ComputeDistance : shape should be edge" << endl;
322       #endif
323       NullifyAIS (theAIS);
324       return;
325     }
326
327     isEdge = Standard_True;
328   }
329   else // nbgeom == 2
330   {
331     isFaces      = IsFace (aShape1) && IsFace (aShape2);
332
333     isEdges      = (aShape1.ShapeType() == TopAbs_EDGE) && (aShape2.ShapeType() == TopAbs_EDGE);
334
335     isEdgeFace   = ((aShape1.ShapeType() == TopAbs_FACE) && (aShape2.ShapeType() == TopAbs_EDGE))
336                    || ((aShape1.ShapeType() == TopAbs_EDGE) && (aShape2.ShapeType() == TopAbs_FACE));
337
338     isVertices  = (aShape1.ShapeType() == TopAbs_VERTEX) && (aShape2.ShapeType() == TopAbs_VERTEX);
339
340     if (!isPlanar && !isFaces && !isEdges && !isVertices)
341     {
342       // Search suitable geometry for dimension
343       if (aShape1.ShapeType() == aShape2.ShapeType())
344       {
345         TopoDS_Vertex aV1, aV2, aV3, aV4;
346         if (aShape1.ShapeType() == TopAbs_WIRE)
347         {
348           TopExp::Vertices (TopoDS::Wire(aShape1), aV1, aV2);
349           TopExp::Vertices (TopoDS::Wire(aShape2), aV3, aV4);
350         }
351         aShape1 = aV1;
352         gp_Pnt aP1 = BRep_Tool::Pnt(aV1);
353         gp_Pnt aP2 = BRep_Tool::Pnt(aV3);
354         gp_Pnt aP3 = BRep_Tool::Pnt (aV4);
355         if (aP1.Distance (aP2) < aP1.Distance (aP3))
356         {
357           aShape2 = aV3;
358           gp_Ax2 ax2 (aP1, gp_Dir (aP2.XYZ() - aP1.XYZ()));
359           aPlane = new Geom_Plane (aP1, ax2.XDirection());
360         }
361         else
362         {
363           aShape2 = aV4;
364           gp_Ax2 anAx2 (aP1, gp_Dir (aP3.XYZ() - aP1.XYZ()));
365           aPlane = new Geom_Plane (aP1, anAx2.XDirection());
366         }
367       }
368       else if (!isEdgeFace)
369       {
370         NullifyAIS (theAIS);
371         return;
372       }
373     }
374   }
375
376   // Check plane
377   Standard_Boolean isCheckPlane = (aDim.IsNull() && !isFaces) || isPlanar;
378   if ((isVertices || isEdges) && !isPlanar)
379   {
380     gp_Pnt aP1, aP2, aP3;
381
382     if (isVertices)
383     {
384       aP1 = BRep_Tool::Pnt (TopoDS::Vertex (aShape1));
385       aP2 = BRep_Tool::Pnt (TopoDS::Vertex (aShape2));
386       aP3 = gp_Pnt (aP1.Y() - 1.0, aP2.X() + 1.0, 0.0);
387     }
388
389     if (isEdges)
390     {
391       TopoDS_Vertex  aV1, aV2, aV3, aV4;
392       TopExp::Vertices (TopoDS::Edge(aShape1), aV1, aV2);
393       TopExp::Vertices (TopoDS::Edge(aShape2), aV3, aV4);
394       aP1 = BRep_Tool::Pnt (aV1);
395       aP2 = BRep_Tool::Pnt (aV2);
396       aP3 = BRep_Tool::Pnt (aV3);
397     }
398
399     GC_MakePlane aPlaneMaker (aP1, aP2, aP3);
400     if (aPlaneMaker.IsDone() && !isPlanar)
401     {
402       aPlane = aPlaneMaker.Value();
403     }
404   }
405
406   if (isCheckPlane && aPlane.IsNull())
407   {
408     #ifdef OCCT_DEBUG
409     cout << "TPrsStd_ConstraintTools::ComputeDistance : null plane" << endl;
410     #endif
411     NullifyAIS (theAIS);
412     return;
413   }
414
415   //  Update of AIS
416   if (aDim.IsNull())
417   {
418     if (isEdge)
419     {
420       aDim = new AIS_LengthDimension (GetEdge (aShape1), aPlane->Pln());
421     }
422     else if (isFaces)
423     {
424       aDim = new AIS_LengthDimension (GetFace (aShape1), GetFace (aShape2));
425     }
426     else
427     {
428       aDim = new AIS_LengthDimension (aShape1, aShape2, aPlane->Pln());
429     }
430
431     if (SaveDrw)
432     {
433         aDim->SetAttributes (aDrawer);
434     }
435   }
436   else
437   {
438     if (isEdge)
439     {
440       aDim->SetMeasuredGeometry (GetEdge(aShape1), aPlane->Pln());
441     }
442     else
443     {
444       aDim->SetMeasuredShapes (aShape1, aShape2);
445     }
446
447     aDim->SetCustomValue (aValue);
448   }
449
450   if (!aPlane.IsNull())
451   {
452     aDim->SetCustomPlane (aPlane->Pln());
453   }
454
455   theAIS = aDim;
456 }
457
458 //=======================================================================
459 //function : ComputePerpendicular
460 //purpose  : 
461 //=======================================================================
462 void TPrsStd_ConstraintTools::ComputePerpendicular(const Handle(TDataXtd_Constraint)& aConst,
463                                                   Handle(AIS_InteractiveObject)& anAIS) 
464 {
465   Standard_Integer nbgeom = aConst->NbGeometries();
466   if (nbgeom < 2) {
467 #ifdef OCCT_DEBUG
468     cout << "TPrsStd_ConstraintTools::ComputePerpendicular: at leat two constraintes are needed" << endl;
469 #endif
470     NullifyAIS(anAIS);
471     return;
472   }
473   
474   TopoDS_Shape shape1,shape2 ;
475   Handle(Geom_Geometry) ageom3;
476   Standard_Boolean is_planar(aConst->IsPlanar());
477   
478   if (is_planar) GetShapesAndGeom(aConst,shape1,shape2,ageom3);
479   else GetTwoShapes(aConst,shape1,shape2); 
480   if (shape1.IsNull() || shape2.IsNull()) {
481 #ifdef OCCT_DEBUG
482     cout << "TPrsStd_ConstraintTools::ComputePerpendicular : null shape" << endl;
483 #endif
484     NullifyAIS(anAIS);
485     return;
486   }
487   GetGoodShape(shape1);
488   GetGoodShape(shape2);
489   //  Update de l'AIS
490   Handle(AIS_PerpendicularRelation) ais;
491   if (anAIS.IsNull()) ais = new AIS_PerpendicularRelation(shape1,shape2);
492   else {
493     ais = Handle(AIS_PerpendicularRelation)::DownCast(anAIS);
494     if (ais.IsNull()) {
495       ais = new AIS_PerpendicularRelation(shape1,shape2);
496     }
497     else {
498       ais->SetFirstShape(shape1);
499       ais->SetSecondShape(shape2);
500     }
501   }
502   
503   if (is_planar) {
504     Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
505     if (aplane.IsNull()) {
506 #ifdef OCCT_DEBUG
507       cout << "TPrsStd_ConstraintTools::ComputePerpendicular: nul plane" << endl;
508 #endif
509       NullifyAIS(anAIS);
510       return;
511     }
512     ais->SetPlane(aplane);
513   }
514   anAIS = ais;
515 }
516
517 //=======================================================================
518 //function : ComputeParallel
519 //purpose  : 
520 //=======================================================================
521 void TPrsStd_ConstraintTools::ComputeParallel(const Handle(TDataXtd_Constraint)& aConst, 
522                                              Handle(AIS_InteractiveObject)& anAIS) 
523 {
524   Standard_Integer nbgeom = aConst->NbGeometries();
525   if (nbgeom < 2) {
526 #ifdef OCCT_DEBUG
527     cout << "TPrsStd_ConstraintTools::ComputeParallel: at least 2 constraintes are needed" << endl;
528 #endif
529     NullifyAIS(anAIS);
530     return;
531   }
532   
533   if (!aConst->IsPlanar()) {
534 #ifdef OCCT_DEBUG
535     cout << "TPrsStd_ConstraintTools::ComputeParallel: must be a planar constraint" << endl;
536 #endif
537     NullifyAIS(anAIS);
538     return;
539   }
540
541   TopoDS_Shape shape1,shape2 ;
542   Handle(Geom_Geometry) ageom3;
543   
544   GetShapesAndGeom(aConst,shape1,shape2,ageom3);
545   if (shape1.IsNull() || shape2.IsNull()) {
546 #ifdef OCCT_DEBUG
547     cout << "TPrsStd_ConstraintTools::ComputeParallel : null shape" << endl;
548 #endif
549     NullifyAIS(anAIS);
550     return;
551   }
552   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
553   if (aplane.IsNull()) {
554 #ifdef OCCT_DEBUG
555     cout << "TPrsStd_ConstraintTools::ComputeParallel: nul plane" << endl;
556 #endif
557     NullifyAIS(anAIS);
558     return;
559   }
560   //  Update de l'AIS
561   GetGoodShape(shape1);
562   GetGoodShape(shape2);
563   Handle(AIS_ParallelRelation) ais;
564   if (anAIS.IsNull()) ais = new AIS_ParallelRelation(shape1,shape2,aplane);
565   else { 
566     ais = Handle(AIS_ParallelRelation)::DownCast(anAIS);
567     if (ais.IsNull()) {
568       ais = new AIS_ParallelRelation(shape1,shape2,aplane);
569     }
570     else {
571       ais->SetFirstShape(shape1);
572       ais->SetSecondShape(shape2);
573       ais->SetPlane(aplane);
574     }
575   }
576   anAIS = ais;
577 }
578 //=======================================================================
579 //function : ComputeSymmetry
580 //purpose  : 
581 //=======================================================================
582 void TPrsStd_ConstraintTools::ComputeSymmetry(const Handle(TDataXtd_Constraint)& aConst,
583                                              Handle(AIS_InteractiveObject)& anAIS) 
584 {
585   Standard_Integer nbgeom = aConst->NbGeometries();
586   if (nbgeom < 3) {
587 #ifdef OCCT_DEBUG
588     cout << "TPrsStd_ConstraintTools::ComputeSymmetry: at least 3 constraintes are needed" << endl;
589 #endif
590     NullifyAIS(anAIS);
591     return;
592   }
593
594   Standard_Boolean is_planar(aConst->IsPlanar());
595   if (!is_planar) {
596 #ifdef OCCT_DEBUG
597     cout << "TPrsStd_ConstraintTools::ComputeSymmetry: must be a planar constraint" << endl;
598 #endif
599     NullifyAIS(anAIS);
600     return;
601   }
602
603   TopoDS_Shape shape1,shape2,shape3 ;
604   Handle(Geom_Geometry) ageom3;
605   GetShapesAndGeom(aConst,shape1,shape2,shape3,ageom3);
606
607   if (shape1.IsNull() || shape2.IsNull() || shape3.IsNull()) {
608 #ifdef OCCT_DEBUG
609     cout << "TPrsStd_ConstraintTools::ComputeSymmetry : null shape" << endl;
610 #endif
611     NullifyAIS(anAIS);
612     return;
613   }
614   GetGoodShape(shape1);
615   GetGoodShape(shape2);
616   GetGoodShape(shape3);
617   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
618   if (aplane.IsNull()) {
619 #ifdef OCCT_DEBUG
620     cout << "TPrsStd_ConstraintTools::ComputeSymmetry: null plane" << endl;
621 #endif
622     NullifyAIS(anAIS);
623     return;
624   }
625   //  Update de l'AIS
626   Handle(AIS_SymmetricRelation) ais;
627   if (anAIS.IsNull()) ais = new AIS_SymmetricRelation(shape3,shape1,shape2,aplane);
628   else {
629     ais = Handle(AIS_SymmetricRelation)::DownCast(anAIS);
630     if (ais.IsNull()) {
631       ais = new AIS_SymmetricRelation(shape3,shape1,shape2,aplane);
632     }
633     else {
634       ais->SetFirstShape(shape1);
635       ais->SetSecondShape(shape2);
636       ais->SetPlane(aplane);
637       ais->SetTool(shape3);
638     }
639   }
640   anAIS = ais;
641 }
642
643 //=======================================================================
644 //function : ComputeMidPoint
645 //purpose  : 
646 //=======================================================================
647 void TPrsStd_ConstraintTools::ComputeMidPoint(const Handle(TDataXtd_Constraint)& aConst,
648                                               Handle(AIS_InteractiveObject)& anAIS) 
649 {
650   Standard_Integer nbgeom = aConst->NbGeometries();
651   if (nbgeom < 3)
652     {
653 #ifdef OCCT_DEBUG
654       cout << "TPrsStd_ConstraintTools::ComputeSymmetry: at least 3 constraints are needed" << endl;
655 #endif
656       NullifyAIS(anAIS);
657       return;
658     }
659
660   Standard_Boolean is_planar(aConst->IsPlanar());
661   if ( !is_planar )
662     {
663 #ifdef OCCT_DEBUG
664       cout << "TPrsStd_ConstraintTools::ComputeSymmetry: must be a planar constraint" << endl;
665 #endif
666       NullifyAIS(anAIS);
667       return;
668     }
669
670   TopoDS_Shape shape1,shape2,shape3;
671   Handle(Geom_Geometry) ageom3;
672   GetShapesAndGeom(aConst,shape1,shape2,shape3,ageom3);
673
674   if (shape1.IsNull() || shape2.IsNull() || shape3.IsNull())
675     {
676 #ifdef OCCT_DEBUG
677       cout << "TPrsStd_ConstraintTools::ComputeSymmetry : null shape" << endl;
678 #endif
679       NullifyAIS(anAIS);
680       return;
681     }
682   GetGoodShape(shape1);
683   GetGoodShape(shape2);
684   GetGoodShape(shape3);
685
686   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
687   if (aplane.IsNull())
688     {
689 #ifdef OCCT_DEBUG
690       cout << "TPrsStd_ConstraintTools::ComputeSymmetry: null plane" << endl;
691 #endif
692       NullifyAIS(anAIS);
693       return;
694     }
695
696   //  Update de l'AIS
697   Handle(AIS_MidPointRelation) ais;
698   if ( anAIS.IsNull() ) ais = new AIS_MidPointRelation(shape3,shape1,shape2,aplane);
699   else
700     {
701       ais = Handle(AIS_MidPointRelation)::DownCast(anAIS);
702       if (ais.IsNull())
703         {
704           ais = new AIS_MidPointRelation(shape3,shape1,shape2,aplane);
705         }
706       else
707         {
708           ais->SetFirstShape(shape1);
709           ais->SetSecondShape(shape2);
710           ais->SetPlane(aplane);
711           ais->SetTool(shape3);
712         }
713     }
714   anAIS = ais;
715 }
716
717 //=======================================================================
718 //function : ComputeTangent
719 //purpose  : 
720 //=======================================================================
721 void TPrsStd_ConstraintTools::ComputeTangent (const Handle(TDataXtd_Constraint)& aConst, 
722                                              Handle(AIS_InteractiveObject)& anAIS) 
723 {
724   Standard_Integer nbgeom = aConst->NbGeometries();
725   if (nbgeom < 2) {
726 #ifdef OCCT_DEBUG
727     cout << "TPrsStd_ConstraintTools::ComputeTangent: at leat two constraintes are needed" << endl;
728 #endif
729     NullifyAIS(anAIS);
730     return;
731   }
732   if (!aConst->IsPlanar()) {
733 #ifdef OCCT_DEBUG
734     cout << "TPrsStd_ConstraintTools::ComputeTangent: must be a planar constraint" << endl;
735 #endif
736     NullifyAIS(anAIS);
737     return;
738   }
739   TopoDS_Shape shape1,shape2 ;
740   Handle(Geom_Geometry) ageom3;
741   
742   GetShapesAndGeom(aConst,shape1,shape2,ageom3);
743   if (shape1.IsNull() || shape2.IsNull()) {
744 #ifdef OCCT_DEBUG
745     cout << "TPrsStd_ConstraintTools::ComputeTangent : null shape" << endl;
746 #endif
747     NullifyAIS(anAIS);
748     return;
749   }
750   GetGoodShape(shape1);
751   GetGoodShape(shape2);
752   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
753   if (aplane.IsNull()) {
754 #ifdef OCCT_DEBUG
755     cout << "TPrsStd_ConstraintTools::ComputeTangent: nul plane" << endl;
756 #endif
757     NullifyAIS(anAIS);
758     return;    
759   }
760   //  Update de l'AIS
761   Handle(AIS_TangentRelation) ais;
762   if (anAIS.IsNull())
763     {
764       ais = new AIS_TangentRelation(shape1,shape2,aplane);
765       ais->SetArrowSize(10000000); // jfa 9/10/2000
766     }
767   else
768     {
769       ais = Handle(AIS_TangentRelation)::DownCast(anAIS);
770       if (ais.IsNull())
771         {
772           ais = new AIS_TangentRelation(shape1,shape2,aplane);
773           ais->SetArrowSize(10000000); // jfa 9/10/2000
774         }
775       else
776         {
777           ais->SetFirstShape(shape1);
778           ais->SetSecondShape(shape2);
779           ais->SetPlane(aplane);
780           ais->SetArrowSize(10000000); // jfa 9/10/2000
781         }
782     }
783   anAIS = ais;
784 }
785
786 //=======================================================================
787 //function : ComputeAngleForOneFace
788 //purpose  : computes AngleDimension for one-conical-face case
789 //=======================================================================
790 void TPrsStd_ConstraintTools::ComputeAngleForOneFace (const Handle(TDataXtd_Constraint)& aConst,
791                                            Handle(AIS_InteractiveObject)& anAIS) 
792 {
793  
794   TopoDS_Shape shape;
795   Handle(Geom_Geometry) ageom3;
796   
797   GetOneShape( aConst, shape ); 
798   if (shape.IsNull() ) {
799 #ifdef OCCT_DEBUG
800     cout << "TPrsStd_ConstraintTools::ComputeAngleForOneFace : null shape" << endl;
801 #endif
802     NullifyAIS(anAIS);
803     return;
804   }
805
806   Standard_Real val1;
807   TCollection_ExtendedString txt;
808   TPrsStd_ConstraintTools::ComputeTextAndValue (aConst,val1,txt,Standard_True);  
809   
810   Handle(AIS_AngleDimension) ais;
811   TopoDS_Face face;
812   if (!anAIS.IsNull()) {
813     ais = Handle(AIS_AngleDimension)::DownCast(anAIS);
814     if(ais.IsNull()) {
815       face = TopoDS::Face( shape );
816       ais =  new AIS_AngleDimension (face);
817     }
818     else {
819       ais->SetMeasuredGeometry(TopoDS::Face( shape ));
820     }
821   }
822   else {
823     face = TopoDS::Face (shape);
824     ais =  new AIS_AngleDimension (face);
825   } 
826
827   anAIS = ais;
828 }
829
830 //=======================================================================
831 //function : CheckIsShapeCompound
832 //purpose  : 
833 //=======================================================================
834
835 static Standard_Boolean CheckIsShapeCompound(TopoDS_Shape& shape, TopoDS_Face& aFace)
836 {
837   if (shape.ShapeType() == TopAbs_COMPOUND) {
838     TopTools_IndexedMapOfShape aFaceMap;
839     TopExp::MapShapes(shape, TopAbs_FACE, aFaceMap);
840     for(Standard_Integer i = 1;i <= aFaceMap.Extent();i++) 
841       {
842         aFace = TopoDS::Face(aFaceMap.FindKey(i));
843         if(!aFace.IsNull()) {
844           shape = aFace;
845           return (Standard_True);
846         }
847       }
848   }
849 #ifdef OCCT_DEBUG
850   cout << "TPrsStd::Compute angle : Shape is not Compound or is Null" <<endl;
851 #endif
852   return (Standard_False);
853 }
854
855 //=======================================================================
856 //function : ComputeAngle
857 //purpose  : 
858 //=======================================================================
859
860 void TPrsStd_ConstraintTools::ComputeAngle (const Handle(TDataXtd_Constraint)& aConst,
861                                            Handle(AIS_InteractiveObject)& anAIS) 
862 {
863   Standard_Integer nbgeom = aConst->NbGeometries();
864   if (nbgeom < 2) {
865     if( nbgeom == 1 ) { ComputeAngleForOneFace( aConst, anAIS ); return; }
866 #ifdef OCCT_DEBUG
867     cout << "TPrsStd_ConstraintTools::ComputeAngle: at least 2 constraints are needed" << endl;
868 #endif
869     NullifyAIS(anAIS);
870     return;
871   }
872   
873   TopoDS_Shape shape1,shape2 ;
874   Handle(Geom_Geometry) ageom3;
875   
876   GetShapesAndGeom (aConst,shape1,shape2,ageom3);
877   if (shape1.IsNull() || shape2.IsNull()) {
878 #ifdef OCCT_DEBUG
879     cout << "TPrsStd_ConstraintTools::ComputeAngle : null shape" << endl;
880 #endif
881     NullifyAIS(anAIS);
882     return;
883   }
884   
885   Standard_Boolean isCurvilinear = Standard_False;
886   if (ageom3.IsNull()) {
887     // on essaie de le calculer
888     
889     TopoDS_Face  aFace;
890     if (shape1.ShapeType() == TopAbs_WIRE)  {
891       BRepBuilderAPI_MakeFace MkF (TopoDS::Wire(shape1),Standard_True);
892       if (MkF.IsDone())  {
893         aFace = MkF.Face();
894         shape1 = aFace;
895       }
896     }
897     else
898       if (shape1.ShapeType() == TopAbs_FACE)
899         aFace    = TopoDS::Face(shape1);
900       else
901         if(!CheckIsShapeCompound(shape1, aFace)) {
902 #ifdef OCCT_DEBUG
903         cout << "Compute angle : Geom type = " << shape1.ShapeType()
904           << " non traite"<<endl;
905 #endif
906         NullifyAIS(anAIS);
907         return;      
908       }
909
910     gp_Ax1 anax1aFace1;
911     gp_Pln aPlnaFace1;
912
913     BRepAdaptor_Surface   aSurfaFace (aFace);
914     GeomAbs_SurfaceType aTypeaFace = aSurfaFace.GetType();
915     if (aTypeaFace  == GeomAbs_Plane) {
916       aPlnaFace1 = aSurfaFace.Plane();
917       anax1aFace1 = aPlnaFace1.Axis(); // Normale au plan
918     } else if (aTypeaFace  == GeomAbs_Cylinder) {
919       gp_Cylinder aCylaFace = aSurfaFace.Cylinder();
920       anax1aFace1 = aCylaFace.Axis();
921     } else if (aTypeaFace  == GeomAbs_Cone) {
922       gp_Cone aCone = aSurfaFace.Cone();
923       anax1aFace1 = aCone.Axis();  
924     } else if (aTypeaFace  == GeomAbs_Torus) {
925       gp_Torus aTore = aSurfaFace.Torus();
926       anax1aFace1 = aTore.Axis();  
927     } else {
928 #ifdef OCCT_DEBUG
929       cout<<"Compute angle"<<aTypeaFace<<" non traite"<<endl;
930 #endif
931       NullifyAIS(anAIS);
932       return;      
933     }
934
935     gp_Ax1 anax1aFace2;
936     gp_Pln aPlnaFace2;
937     if (shape2.ShapeType() == TopAbs_WIRE)  {
938       BRepBuilderAPI_MakeFace MkF (TopoDS::Wire(shape2),Standard_True);
939       if (MkF.IsDone())  {
940         aFace = MkF.Face();
941         shape2 = aFace;
942       }
943     }
944     else
945       if (shape2.ShapeType() == TopAbs_FACE)
946         aFace    = TopoDS::Face(shape2); 
947     else  
948       if(!CheckIsShapeCompound(shape2, aFace)) {
949 #ifdef OCCT_DEBUG
950         cout << "Compute angle : Geom type = " << shape2.ShapeType()
951           << " non traite"<<endl;
952 #endif
953         NullifyAIS(anAIS);
954         return;      
955       }
956     
957     aSurfaFace.Initialize(aFace);
958     aTypeaFace = aSurfaFace.GetType();
959     if (aTypeaFace  == GeomAbs_Plane) {
960       aPlnaFace2 = aSurfaFace.Plane();
961       anax1aFace2 = aPlnaFace2.Axis(); // Normale au plan
962     } else if (aTypeaFace  == GeomAbs_Cylinder) {
963       gp_Cylinder aCylaFace = aSurfaFace.Cylinder();
964       anax1aFace2 = aCylaFace.Axis();
965     } else if (aTypeaFace  == GeomAbs_Cone) {
966       gp_Cone aCone = aSurfaFace.Cone();
967       anax1aFace2 = aCone.Axis();  
968     } else if (aTypeaFace  == GeomAbs_Torus) {
969       gp_Torus aTore = aSurfaFace.Torus();
970       anax1aFace2 = aTore.Axis();  
971     } else {
972 #ifdef OCCT_DEBUG
973       cout << "Compute angle " << aTypeaFace << " non traite"<<endl;
974 #endif
975       NullifyAIS(anAIS);
976       return;      
977     }
978
979     if (aTypeaFace==GeomAbs_Plane) {
980       if (!anax1aFace1.IsParallel(anax1aFace2, Precision::Angular())) {
981         
982         IntAna_QuadQuadGeo IntersectPlane (aPlnaFace1, aPlnaFace2, Precision::Angular(), Precision::Angular());
983         if (IntersectPlane.IsDone() &&
984             (IntersectPlane.TypeInter() != IntAna_Empty))  {
985           gp_Lin aLine = IntersectPlane.Line(1);
986           Handle(Geom_Line) computedgeom3 = new Geom_Line (aLine);
987           ageom3 = computedgeom3;
988         } else {
989 #ifdef OCCT_DEBUG
990           cout<<"Compute angle insertection of planes failed"<<endl;
991 #endif
992           NullifyAIS(anAIS);
993           return;            
994         }
995       } else {
996         
997 #ifdef OCCT_DEBUG
998         cout<<"Compute angle faces are //"<<endl;
999 #endif
1000         NullifyAIS(anAIS);
1001         return;            
1002       }
1003     } else {
1004       // Curvilinear faces...
1005       isCurvilinear = Standard_True;
1006     }
1007   } // endif (ageom3.IsNull())
1008
1009
1010   Standard_Boolean isplan(Standard_False);
1011
1012   if (!isCurvilinear) {
1013     if (ageom3->IsKind(STANDARD_TYPE(Geom_Plane))) isplan = Standard_True;
1014     else if (ageom3->IsKind(STANDARD_TYPE(Geom_Line))) isplan = Standard_False;
1015     else {
1016 #ifdef OCCT_DEBUG
1017       cout << "TPrsStd_ConstraintTools::ComputeAngle: unknown 3rd arg " << endl;
1018 #endif
1019       NullifyAIS(anAIS);
1020       return;
1021     }
1022   }
1023   Standard_Real val1;
1024   TCollection_ExtendedString txt;
1025   ComputeTextAndValue (aConst,val1,txt,Standard_True);  
1026   
1027   Standard_Boolean toCreate (Standard_True);
1028   Standard_Boolean isface(shape1.ShapeType()==TopAbs_FACE);
1029   
1030   Handle(AIS_AngleDimension) ais;
1031   if (!anAIS.IsNull()) {
1032     ais = Handle(AIS_AngleDimension)::DownCast(anAIS);
1033     if( ais.IsNull() ) {
1034       toCreate = Standard_True;
1035     }
1036     else toCreate = Standard_False;
1037   }
1038   
1039   Standard_Integer ExtShape(0);
1040   if (toCreate)  {
1041     // Creation de l'AIS
1042     if (isplan) {
1043       if(!isface) {
1044         FindExternalShape(aConst,ExtShape);
1045         GetGoodShape(shape1);
1046         GetGoodShape(shape2);
1047         ais = new AIS_AngleDimension (TopoDS::Edge(shape1),
1048                                       TopoDS::Edge(shape2));
1049       }
1050     }
1051     else { 
1052       if (isCurvilinear) {
1053   ais = new AIS_AngleDimension (TopoDS::Face(shape1),
1054                                 TopoDS::Face(shape2));
1055       }
1056       else if (isface) {
1057   ais =  new AIS_AngleDimension (TopoDS::Face(shape1),
1058                                  TopoDS::Face(shape2));
1059       }
1060     }
1061   }
1062   else {
1063     // Update de l'AIS
1064     if (isplan) {
1065       GetGoodShape(shape1);
1066       GetGoodShape(shape2);
1067     }
1068     ais->SetMeasuredGeometry (TopoDS::Face (shape1), TopoDS::Face (shape2));
1069     if (isplan)
1070       ais->SetCustomPlane (Handle(Geom_Plane)::DownCast (ageom3)->Pln());
1071     else if (!isCurvilinear)
1072     {
1073       gp_Pln aPlane;
1074       aPlane.SetAxis (Handle(Geom_Line)::DownCast (ageom3)->Position());
1075       ais->SetCustomPlane (aPlane);
1076     }
1077   }
1078   anAIS = ais;
1079 }
1080
1081
1082 //=======================================================================
1083 //function : ComputeConcentric
1084 //purpose  : 
1085 //=======================================================================
1086 void TPrsStd_ConstraintTools::ComputeConcentric(const Handle(TDataXtd_Constraint)& aConst,
1087                                                Handle(AIS_InteractiveObject)& anAIS) 
1088 {
1089   Standard_Integer nbgeom = aConst->NbGeometries();
1090   if (nbgeom < 2) {
1091     throw Standard_ProgramError("TPrsStd_ConstraintTools::ComputeConcentric: at least 2 constraintes are needed");
1092   }
1093   if (!aConst->IsPlanar()) {
1094 #ifdef OCCT_DEBUG
1095     cout << "TPrsStd_ConstraintTools::ComputeConcentric: must be a planar constraint" << endl;
1096 #endif
1097     NullifyAIS(anAIS);
1098     return;
1099   }
1100   TopoDS_Shape shape1,shape2 ;
1101   Handle(Geom_Geometry) ageom3;
1102   
1103   GetShapesAndGeom(aConst,shape1,shape2,ageom3);
1104   if (shape1.IsNull() || shape2.IsNull()) {
1105 #ifdef OCCT_DEBUG
1106     cout << "TPrsStd_ConstraintTools::ComputeConcentric : null shape" << endl;
1107 #endif
1108     NullifyAIS(anAIS);
1109     return;
1110   }
1111
1112   GetGoodShape(shape1);
1113   GetGoodShape(shape2);
1114
1115 //ota : to allow concentric constraint display between vertex and edge
1116   if (shape1.ShapeType() != TopAbs_EDGE && shape2.ShapeType() != TopAbs_EDGE) {
1117 #ifdef OCCT_DEBUG
1118     cout << "TPrsStd_ConstraintTools::ComputeConcentric: concentric between two vertexes : NOT DISPLAYED" << endl;;
1119 #endif
1120     NullifyAIS(anAIS);
1121     return;
1122   }
1123
1124   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
1125   if (aplane.IsNull()) {
1126 #ifdef OCCT_DEBUG
1127     cout << "TPrsStd_ConstraintTools::ComputeConcentric: nul plane" << endl;;
1128 #endif
1129     NullifyAIS(anAIS);
1130     return;
1131   }
1132   //  Update de l'AIS
1133   Handle(AIS_ConcentricRelation) ais;
1134   if (!anAIS.IsNull()) {
1135     ais = Handle(AIS_ConcentricRelation)::DownCast(anAIS);
1136     if (ais.IsNull()) {
1137       ais = new AIS_ConcentricRelation (shape1,shape2,aplane);
1138     } 
1139     else {
1140       ais->SetFirstShape(shape1);
1141       ais->SetSecondShape(shape2);
1142       ais->SetPlane(aplane);
1143     }
1144   }
1145   else {
1146     ais = new AIS_ConcentricRelation (shape1,shape2,aplane);
1147   }
1148
1149   anAIS = ais;
1150 }
1151
1152 //=======================================================================
1153 //function : ComputeRadius
1154 //purpose  : 
1155 //=======================================================================
1156 void TPrsStd_ConstraintTools::ComputeRadius (const Handle(TDataXtd_Constraint)& aConst,
1157                                             Handle(AIS_InteractiveObject)& anAIS) 
1158 {
1159   Standard_Integer nbgeom = aConst->NbGeometries();
1160   if (nbgeom < 1) {
1161 #ifdef OCCT_DEBUG
1162     cout << "TPrsStd_ConstraintTools::ComputeRadius: at least one constrainte is needed" << endl;    
1163 #endif
1164     NullifyAIS(anAIS);
1165     return;
1166   }
1167
1168   TopoDS_Shape shape1 ;
1169   GetOneShape (aConst,shape1);
1170   if (shape1.IsNull()) {
1171 #ifdef OCCT_DEBUG
1172     cout << "TPrsStd_ConstraintTools::ComputeRadius: null shape" << endl;
1173 #endif
1174     NullifyAIS(anAIS);
1175     return;
1176   }
1177
1178   // POP on teste si ce n'est pas un compound
1179   if (shape1.ShapeType()==TopAbs_COMPOUND ||
1180       shape1.ShapeType()==TopAbs_COMPSOLID ||
1181       shape1.ShapeType()==TopAbs_SOLID ||
1182       shape1.ShapeType()==TopAbs_SHELL ) {
1183 #ifdef OCCT_DEBUG
1184     cout << "TPrsStd_ConstraintTools::ComputeRadius: not good shape" << endl;
1185 #endif
1186     NullifyAIS(anAIS);
1187     return;
1188   }
1189       
1190   if (IsFace(shape1))
1191     shape1 = GetFace(shape1);
1192
1193   Standard_Real val1;
1194   TCollection_ExtendedString txt;
1195   ComputeTextAndValue(aConst,val1,txt,Standard_False);
1196
1197   //  Update de l'AIS
1198   Standard_Boolean isplanar(aConst->IsPlanar());
1199   if (isplanar) GetGoodShape(shape1);
1200
1201   Handle(AIS_RadiusDimension) ais;
1202   if (!anAIS.IsNull()) {
1203     ais = Handle(AIS_RadiusDimension)::DownCast(anAIS);
1204     if (ais.IsNull()) {
1205       ais = new AIS_RadiusDimension (shape1);
1206     }
1207     else {
1208       ais->SetMeasuredGeometry(shape1);
1209     }
1210   }
1211   else ais = new AIS_RadiusDimension (shape1);
1212
1213   if (isplanar) {
1214     Handle(Geom_Geometry) ageom2;
1215     GetGeom(aConst,ageom2);
1216     Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom2);
1217     if (aplane.IsNull()) {
1218 #ifdef OCCT_DEBUG
1219       cout << "TPrsStd_ConstraintTools::ComputeRadius: nul plane" << endl;
1220 #endif
1221       NullifyAIS(anAIS);
1222       return;
1223     }
1224     ais->SetCustomPlane(aplane->Pln());
1225   }
1226   anAIS = ais;
1227 }
1228 // ota -- begin --
1229 //=======================================================================
1230 //function : ComputeMinRadius
1231 //purpose  : 
1232 //=======================================================================
1233 void TPrsStd_ConstraintTools::ComputeMinRadius (const Handle(TDataXtd_Constraint)& aConst,
1234                                                 Handle(AIS_InteractiveObject)& anAIS) 
1235 {
1236   Standard_Integer nbgeom = aConst->NbGeometries();
1237   if (nbgeom < 1) {
1238 #ifdef OCCT_DEBUG
1239     cout << "TPrsStd_ConstraintTools::ComputeMinRadius: at least one constrainte is needed" << endl;    
1240 #endif
1241     NullifyAIS(anAIS);
1242     return;
1243   }
1244
1245   TopoDS_Shape shape1 ;
1246   GetOneShape (aConst,shape1);
1247   if (shape1.IsNull()) {
1248 #ifdef OCCT_DEBUG
1249     cout << "TPrsStd_ConstraintTools::ComputeMinradius: null shape" << endl;
1250 #endif
1251     NullifyAIS(anAIS);
1252     return;
1253   }
1254
1255   // POP on teste si ce n'est pas un compound
1256   if (shape1.ShapeType()==TopAbs_COMPOUND ||
1257       shape1.ShapeType()==TopAbs_COMPSOLID ||
1258       shape1.ShapeType()==TopAbs_SOLID ||
1259       shape1.ShapeType()==TopAbs_SHELL ) {
1260 #ifdef OCCT_DEBUG
1261     cout << "TPrsStd_ConstraintTools::ComputeMinRadius: not good shape" << endl;
1262 #endif
1263     NullifyAIS(anAIS);
1264     return;
1265   }
1266       
1267   if (IsFace(shape1))
1268     shape1 = GetFace(shape1);
1269
1270   Standard_Real val1;
1271   TCollection_ExtendedString txt;
1272   ComputeTextAndValue(aConst,val1,txt,Standard_False);
1273
1274   //  Update de l'AIS
1275   Standard_Boolean isplanar(aConst->IsPlanar());
1276   if (isplanar) GetGoodShape(shape1);
1277
1278   Handle(AIS_MinRadiusDimension) ais;
1279   if (!anAIS.IsNull()) {
1280     ais = Handle(AIS_MinRadiusDimension)::DownCast(anAIS);
1281     if (ais.IsNull()) {
1282       ais = new AIS_MinRadiusDimension (shape1,val1,txt);
1283     }
1284     else {
1285       ais->SetValue(val1);
1286       ais->SetFirstShape(shape1);
1287       ais->SetText(txt);    
1288     }
1289   }
1290   else ais = new AIS_MinRadiusDimension (shape1,val1,txt);
1291
1292   if (isplanar) {
1293     Handle(Geom_Geometry) ageom2;
1294     GetGeom(aConst,ageom2);
1295     Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom2);
1296     if (aplane.IsNull()) {
1297 #ifdef OCCT_DEBUG
1298       cout << "TPrsStd_ConstraintTools::ComputeMinRadius: nul plane" << endl;
1299 #endif
1300       NullifyAIS(anAIS);
1301       return;
1302     }
1303     ais->SetPlane(aplane);
1304   }
1305   anAIS = ais;
1306 }
1307
1308 //=======================================================================
1309 //function : ComputeMaxRadius
1310 //purpose  : 
1311 //=======================================================================
1312 void TPrsStd_ConstraintTools::ComputeMaxRadius (const Handle(TDataXtd_Constraint)& aConst,
1313                                                 Handle(AIS_InteractiveObject)& anAIS) 
1314 {
1315   Standard_Integer nbgeom = aConst->NbGeometries();
1316   if (nbgeom < 1) {
1317 #ifdef OCCT_DEBUG
1318     cout << "TPrsStd_ConstraintTools::ComputeMaxRadius: at least one constrainte is needed" << endl;    
1319 #endif
1320     NullifyAIS(anAIS);
1321     return;
1322   }
1323
1324   TopoDS_Shape shape1 ;
1325   GetOneShape (aConst,shape1);
1326   if (shape1.IsNull()) {
1327 #ifdef OCCT_DEBUG
1328     cout << "TPrsStd_ConstraintTools::ComputeMaxradius: null shape" << endl;
1329 #endif
1330     NullifyAIS(anAIS);
1331     return;
1332   }
1333
1334   // POP on teste si ce n'est pas un compound
1335   if (shape1.ShapeType()==TopAbs_COMPOUND ||
1336       shape1.ShapeType()==TopAbs_COMPSOLID ||
1337       shape1.ShapeType()==TopAbs_SOLID ||
1338       shape1.ShapeType()==TopAbs_SHELL ) {
1339 #ifdef OCCT_DEBUG
1340     cout << "TPrsStd_ConstraintTools::ComputeMaxRadius: not good shape" << endl;
1341 #endif
1342     NullifyAIS(anAIS);
1343     return;
1344   }
1345
1346   if (IsFace(shape1))
1347     shape1 = GetFace(shape1);
1348
1349   Standard_Real val1;
1350   TCollection_ExtendedString txt;
1351   ComputeTextAndValue(aConst,val1,txt,Standard_False);
1352
1353   //  Update de l'AIS
1354   Standard_Boolean isplanar(aConst->IsPlanar());
1355   if (isplanar) GetGoodShape(shape1);
1356
1357   Handle(AIS_MaxRadiusDimension) ais;
1358   if (!anAIS.IsNull()) {
1359     ais = Handle(AIS_MaxRadiusDimension)::DownCast(anAIS);
1360     if (ais.IsNull()) {
1361       ais = new AIS_MaxRadiusDimension (shape1,val1,txt);
1362     }
1363     else {
1364       ais->SetValue(val1);
1365       ais->SetFirstShape(shape1);
1366       ais->SetText(txt);    
1367     }
1368   }
1369   else ais = new AIS_MaxRadiusDimension (shape1,val1,txt);
1370
1371   if (isplanar) {
1372     Handle(Geom_Geometry) ageom2;
1373     GetGeom(aConst,ageom2);
1374     Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom2);
1375     if (aplane.IsNull()) {
1376 #ifdef OCCT_DEBUG
1377       cout << "TPrsStd_ConstraintTools::ComputeMaxRadius: nul plane" << endl;
1378 #endif
1379       NullifyAIS(anAIS);
1380       return;
1381     }
1382     ais->SetPlane(aplane);
1383   }
1384   anAIS = ais;
1385 }
1386
1387 //=======================================================================
1388 //function : ComputeEqualDistance
1389 //purpose  : 
1390 //=======================================================================
1391 void TPrsStd_ConstraintTools::ComputeEqualDistance(const Handle(TDataXtd_Constraint)& aConst,
1392                                                    Handle(AIS_InteractiveObject)& anAIS) 
1393 {
1394   Standard_Integer nbgeom = aConst->NbGeometries();
1395   if (nbgeom < 4) {
1396 #ifdef OCCT_DEBUG
1397       cout << "TPrsStd_ConstraintTools::ComputeEqual: at least four geometries are needed" << endl;;
1398 #endif
1399       NullifyAIS(anAIS);
1400       return;
1401     }
1402   TopoDS_Shape aShape1, aShape2, aShape3, aShape4;
1403   Handle(Geom_Geometry) aGeom;
1404   GetShapesAndGeom(aConst, aShape1, aShape2, aShape3, aShape4, aGeom);
1405    if (aShape1.IsNull()||aShape2.IsNull()||
1406        aShape3.IsNull()||aShape4.IsNull()) {
1407 #ifdef OCCT_DEBUG
1408     cout << "TPrsStd_ConstraintTools::ComputeEqualDistance : null shape" << endl;
1409 #endif
1410     NullifyAIS(anAIS);
1411     return;
1412   }
1413
1414   GetGoodShape(aShape1);
1415   GetGoodShape(aShape2);
1416   GetGoodShape(aShape3);
1417   GetGoodShape(aShape4);
1418   
1419   if (!CheckShapesPair(aShape1, aShape2) || 
1420       !CheckShapesPair(aShape3, aShape4)){
1421 #ifdef OCCT_DEBUG
1422         cout << "TPrsStd_ConstraintTools::ComputeEqualDistance : at least one pair of shapes is incorrect"<<endl;
1423 #endif
1424         NullifyAIS(anAIS);
1425         return;
1426       }
1427
1428   //Get the plane
1429   Standard_Boolean IsPlanar(aConst->IsPlanar());
1430   Handle(Geom_Plane) aPlane ;
1431   if(IsPlanar) aPlane = Handle(Geom_Plane)::DownCast(aGeom) ; 
1432  
1433   if (!IsPlanar || aPlane.IsNull()) {
1434     //create the plane
1435 #ifdef OCCT_DEBUG
1436     cout<< "The constraint plane is not assigned "<< endl;
1437 #endif
1438     NullifyAIS(anAIS);
1439     return;
1440   }
1441   
1442   //Update AIS
1443   Handle(AIS_EqualDistanceRelation) ais; 
1444   if (!anAIS.IsNull()) {
1445     {
1446       ais = Handle(AIS_EqualDistanceRelation)::DownCast(anAIS);
1447     
1448       if (ais.IsNull()) 
1449         ais = new AIS_EqualDistanceRelation(aShape1, aShape2, aShape3, aShape4, aPlane);
1450       
1451       else {
1452         ais->SetFirstShape(aShape1);
1453         ais->SetSecondShape(aShape2);
1454         ais->SetShape3(aShape3);
1455         ais->SetShape4(aShape4);
1456         ais->SetPlane(aPlane);
1457       }
1458     }
1459   }
1460   else ais = new AIS_EqualDistanceRelation(aShape1, aShape2, aShape3, aShape4, aPlane);
1461   
1462   anAIS = ais;  
1463
1464   return;
1465 }
1466
1467 //======================================================================
1468 // function : CheckShapesPair
1469 // purpose  : checks the types of two shapes. 
1470 //            If the types aShape1 and aShape2 are EDGE - EDGE,
1471 //                                              or EDGE - VERTEX,
1472 //                                              or VERTEX - VERTEX,
1473 //                                              or CIRCLE - CIRCLE,
1474 //                                              or CIRCLE - VERTEX,
1475 //            then function returns TRUE, otherwise FALSE.
1476 //======================================================================
1477 static Standard_Boolean CheckShapesPair(const TopoDS_Shape& aShape1, 
1478                                     const TopoDS_Shape& aShape2)
1479 {
1480   //Check whether the shapes form a correct pair.
1481   if (aShape1.ShapeType() == TopAbs_EDGE && aShape2.ShapeType() == TopAbs_EDGE)
1482     {
1483       BRepAdaptor_Curve aCurve1(TopoDS::Edge(aShape1));
1484       BRepAdaptor_Curve aCurve2(TopoDS::Edge(aShape2));
1485       if (aCurve1.GetType() == GeomAbs_Line && aCurve2.GetType() == GeomAbs_Line)
1486         { //Are lines parallel ?
1487           gp_Dir aDir1 = aCurve1.Line().Direction();
1488           gp_Dir aDir2 = aCurve2.Line().Direction();
1489           if (!(aDir1.IsParallel(aDir2, Precision::Confusion()))) {
1490 #ifdef OCCT_DEBUG
1491             cout << " Lines are not parallel"<<endl;
1492 #endif
1493             return Standard_False;
1494           }
1495         }
1496       else if (aCurve1.GetType() == GeomAbs_Circle && aCurve2.GetType() == GeomAbs_Circle)
1497         {
1498           gp_Pnt aCntr1 = aCurve1.Circle().Location(); //get the circle center
1499           gp_Pnt aCntr2 = aCurve2.Circle().Location(); //get the circle center
1500           if (!aCntr1.IsEqual(aCntr2,Precision::Confusion())){
1501 #ifdef OCCT_DEBUG
1502             cout << " Circles are not concentric"<<endl;
1503 #endif
1504             return Standard_False;
1505           }
1506         }
1507       else {
1508 #ifdef OCCT_DEBUG
1509         cout << "Incorrect pair of curves "<<endl;
1510 #endif
1511         return Standard_False;
1512       }
1513     }
1514   else if ( aShape1.ShapeType() != TopAbs_VERTEX || aShape2.ShapeType() != TopAbs_VERTEX)
1515     {
1516       gp_Pnt aPnt;
1517       BRepAdaptor_Curve aCurve;
1518       if ( aShape1.ShapeType() == TopAbs_VERTEX) {
1519         aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape1));
1520         aCurve.Initialize(TopoDS::Edge(aShape2));
1521       }
1522       else {
1523         aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape2));
1524         aCurve.Initialize(TopoDS::Edge(aShape1));
1525       }
1526       if ( aCurve.GetType() == GeomAbs_Circle)
1527         {
1528           gp_Pnt aCntr = aCurve.Circle().Location();
1529           if (!aCntr.IsEqual(aPnt, Precision::Confusion())){
1530 #ifdef OCCT_DEBUG
1531             cout << " The point doesn't coincide with the circle center"<<endl;
1532 #endif
1533             return Standard_False;
1534           }
1535         }
1536     }
1537   return Standard_True;
1538 }
1539
1540 //=======================================================================
1541 //function : ComputeEqualRadius
1542 //purpose  : 
1543 //=======================================================================
1544 void TPrsStd_ConstraintTools::ComputeEqualRadius(const Handle(TDataXtd_Constraint)& aConst,
1545                                                  Handle(AIS_InteractiveObject)& anAIS) 
1546 {
1547   Standard_Integer nbgeom = aConst->NbGeometries();
1548   if (nbgeom < 2) {
1549 #ifdef OCCT_DEBUG
1550     cout << "TPrsStd_ConstraintTools::ComputeEqualRadius: at least two geometries are needed" << endl;;
1551 #endif
1552     NullifyAIS(anAIS);
1553     return;
1554   }
1555   TopoDS_Shape shape1, shape2;
1556   Handle(Geom_Geometry) ageom3;
1557   
1558   GetShapesAndGeom(aConst, shape1, shape2, ageom3);
1559   if (shape1.IsNull()||shape2.IsNull()) {
1560 #ifdef OCCT_DEBUG
1561     cout << "TPrsStd_ConstraintTools::ComputeEqualRadius : null shape" << endl;
1562 #endif
1563     NullifyAIS(anAIS);
1564     return;
1565   }
1566   
1567   //  Update AIS
1568   Standard_Boolean IsPlanar(aConst->IsPlanar());
1569  
1570   GetGoodShape(shape1);
1571   GetGoodShape(shape2);
1572   const TopoDS_Edge edge1 = TopoDS::Edge(shape1);
1573   const TopoDS_Edge edge2 = TopoDS::Edge(shape2);
1574   Handle(Geom_Plane) aplane ;
1575   
1576   if (IsPlanar) aplane = Handle(Geom_Plane)::DownCast(ageom3) ;
1577   
1578   if (!IsPlanar || aplane.IsNull()) {
1579     // check are the planes of edge1 and edge2 coincident
1580     BRepAdaptor_Curve aCurve( edge1 );
1581     Handle( Geom_Curve ) aProjCurve = aCurve.Curve().Curve();
1582     gp_Circ aCircle = (Handle( Geom_Circle )::DownCast( aProjCurve ))->Circ();
1583     gp_Ax3 anAx31(aCircle.Position()); //get the circle axis
1584     // get the circle plane 
1585     Handle(Geom_Plane) aPlane1 = new Geom_Plane (anAx31);
1586
1587     aCurve.Initialize(edge2);
1588     aProjCurve = aCurve.Curve().Curve();
1589     aCircle = (Handle( Geom_Circle )::DownCast( aProjCurve ))->Circ();
1590     gp_Ax3 anAx32(aCircle.Position()); //get the circle axis
1591     // get the circle plane 
1592     Handle(Geom_Plane) aPlane2 = new Geom_Plane (anAx32);
1593
1594     Standard_Real A, B, C ,D1, D2;
1595     aPlane1->Coefficients(A, B, C, D1);//Get normalized coefficients
1596     aPlane2->Coefficients(A, B, C, D2);//Get normalized coefficients
1597     const gp_Dir& aDir1 = anAx31.Direction();
1598     const gp_Dir& aDir2 = anAx32.Direction();
1599     
1600     if(Abs(D1 - D2) < Precision::Confusion() &&
1601        aDir1.IsParallel(aDir2, Precision::Confusion()))
1602       aplane = aPlane2;
1603     else {
1604 #ifdef OCCT_DEBUG
1605       cout << "TPrsStd_ConstraintTools::ComputeRadiusRelation: nul plane" << endl;
1606 #endif
1607       NullifyAIS(anAIS);
1608       return;
1609     }
1610   }   
1611   Handle(AIS_EqualRadiusRelation) ais;
1612   if (!anAIS.IsNull()) {
1613     ais = Handle(AIS_EqualRadiusRelation)::DownCast(anAIS);
1614     
1615     if (ais.IsNull()) {
1616       ais = new AIS_EqualRadiusRelation(edge1, edge2, aplane);
1617       }
1618     else {
1619       ais->SetFirstShape(shape1);
1620       ais->SetSecondShape(shape2);
1621       ais->SetPlane(aplane);
1622     }
1623   }
1624   else {
1625     ais = new AIS_EqualRadiusRelation(edge1, edge2, aplane);
1626   }
1627   
1628   anAIS = ais;
1629 }
1630 //ota -- end --
1631
1632 //=======================================================================
1633 //function : ComputeDiameter
1634 //purpose  : 
1635 //=======================================================================
1636 void TPrsStd_ConstraintTools::ComputeDiameter(const Handle(TDataXtd_Constraint)& aConst,
1637                                              Handle(AIS_InteractiveObject)& anAIS) 
1638 {
1639   Standard_Integer nbgeom = aConst->NbGeometries();
1640   if (nbgeom < 1) {
1641 #ifdef OCCT_DEBUG
1642     cout << "TPrsStd_ConstraintTools::ComputeDiameter: at least one constrainte is needed" << endl;;
1643 #endif
1644     NullifyAIS(anAIS);
1645     return;
1646   }
1647   TopoDS_Shape shape1 ;
1648   
1649   GetOneShape(aConst,shape1);
1650   if (shape1.IsNull()) {
1651 #ifdef OCCT_DEBUG
1652     cout << "TPrsStd_ConstraintTools::ComputeDiameter : null shape" << endl;
1653 #endif
1654     NullifyAIS(anAIS);
1655     return;
1656   }
1657   Standard_Real val1;
1658   TCollection_ExtendedString txt;
1659   ComputeTextAndValue(aConst,val1,txt,Standard_False);
1660
1661   //  Update de l'AIS
1662   Standard_Boolean IsPlanar(aConst->IsPlanar());
1663   if (IsPlanar) GetGoodShape(shape1);
1664   Handle(AIS_DiameterDimension) ais;
1665   if (!anAIS.IsNull()) {
1666     ais = Handle(AIS_DiameterDimension)::DownCast(anAIS);
1667     if (ais.IsNull()) {
1668       ais = new AIS_DiameterDimension (shape1);
1669     }
1670     else {
1671       ais->SetMeasuredGeometry(shape1);
1672     }
1673   }
1674   else ais = new AIS_DiameterDimension (shape1);
1675
1676   if (IsPlanar) {
1677     Handle(Geom_Geometry) ageom2;
1678     GetGeom(aConst,ageom2);
1679     Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom2);
1680     if (aplane.IsNull()) {
1681 #ifdef OCCT_DEBUG
1682       cout << "TPrsStd_ConstraintTools::ComputeDiameter: nul plane" << endl;
1683 #endif
1684       NullifyAIS(anAIS);
1685       return;
1686     }
1687     //ais->SetCustomPlane(aplane);
1688   }
1689   anAIS = ais;
1690 }
1691
1692
1693 //=======================================================================
1694 //function : ComputeFix
1695 //purpose  : 
1696 //=======================================================================
1697 void TPrsStd_ConstraintTools::ComputeFix(const Handle(TDataXtd_Constraint)& aConst,
1698                                         Handle(AIS_InteractiveObject)& anAIS) 
1699 {
1700   Standard_Integer nbgeom = aConst->NbGeometries();
1701   if (nbgeom < 1) {
1702 #ifdef OCCT_DEBUG
1703     cout << "TPrsStd_ConstraintTools::ComputeFix: at least one constrainte is needed" << endl;;
1704 #endif
1705     NullifyAIS(anAIS);
1706     return;
1707   }
1708   if (!aConst->IsPlanar()) {
1709 #ifdef OCCT_DEBUG
1710     cout << "TPrsStd_ConstraintTools::ComputeFix: must be a planar constraint" << endl;;
1711 #endif
1712     NullifyAIS(anAIS);
1713     return;
1714   }
1715
1716   TopoDS_Shape shape1 ;
1717   Handle(Geom_Geometry) ageom2;
1718   
1719   GetOneShape(aConst,shape1);
1720   if (shape1.IsNull()) {
1721 #ifdef OCCT_DEBUG
1722     cout << "TPrsStd_ConstraintTools::ComputeFix : null shape" << endl;
1723 #endif
1724     NullifyAIS(anAIS);
1725     return;
1726   }  
1727   GetGoodShape(shape1);
1728   GetGeom(aConst,ageom2);
1729   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom2);
1730   if (aplane.IsNull()) {
1731 #ifdef OCCT_DEBUG
1732     cout << "TPrsStd_ConstraintTools::ComputeFix: nul plane" << endl;
1733 #endif
1734     NullifyAIS(anAIS);
1735     return;
1736   }
1737   //  Update de l'AIS
1738   Handle(AIS_FixRelation) ais;
1739   if (!anAIS.IsNull()) {
1740     ais = Handle(AIS_FixRelation)::DownCast(anAIS);
1741     if (ais.IsNull()) {
1742       ais = new AIS_FixRelation (shape1,aplane);
1743     }
1744     else {
1745       ais->SetFirstShape(shape1);
1746       ais->SetPlane(aplane);
1747     }
1748   }
1749   else ais = new AIS_FixRelation (shape1,aplane);
1750
1751   anAIS = ais;
1752 }
1753
1754 //=======================================================================
1755 //function : ComputeOffset
1756 //purpose  : 
1757 //=======================================================================
1758 void TPrsStd_ConstraintTools::ComputeOffset (const Handle(TDataXtd_Constraint)& aConst,
1759                                             Handle(AIS_InteractiveObject)& anAIS) 
1760 {
1761   // Get plane for planar constraint
1762   Standard_Boolean is_planar (aConst->IsPlanar());
1763   Handle(Geom_Plane) aplane;      
1764   if (is_planar) {
1765     Handle(Geom_Geometry) ageom;
1766     GetGeom (aConst,ageom);
1767     aplane = Handle(Geom_Plane)::DownCast (ageom);
1768     if (aplane.IsNull()) {
1769 #ifdef OCCT_DEBUG
1770       cout << "TPrsStd_ConstraintTools::ComputeOffset: null plane" << endl;
1771 #endif
1772       NullifyAIS(anAIS);
1773       return;
1774     }
1775   }
1776
1777   // Get shapes
1778   TopoDS_Shape S1, S2;
1779   Standard_Integer nbgeom = aConst->NbGeometries();
1780   if (nbgeom == 1) {
1781     Handle(TNaming_NamedShape) ageom1 = aConst->GetGeometry(1);
1782     // c'est une shape qui contient les faces generees par les faces d'origines
1783     TNaming_Iterator It (ageom1);
1784     if (It.More()) {
1785       S1 = It.OldShape();
1786       S2 = It.NewShape();
1787     }
1788   }
1789   else
1790   if (nbgeom == 2)  {
1791     // Get geometry of the constraint
1792     GetTwoShapes (aConst,S1,S2);
1793   }
1794
1795   if (S1.IsNull() || S2.IsNull()) {
1796 #ifdef OCCT_DEBUG
1797     cout << "TPrsStd_ConstraintTools::ComputeOffset: null shape" << endl;
1798 #endif
1799     NullifyAIS(anAIS);
1800     return;
1801   }
1802
1803
1804   Standard_Real val1;
1805   TCollection_ExtendedString txt;
1806   Handle(AIS_LengthDimension) ais;
1807   //Handle(Prs3d_Drawer) aDrawer;
1808
1809   if (nbgeom == 1)
1810   {
1811     ComputeTextAndValue (aConst,val1,txt,Standard_False);
1812     if (!anAIS.IsNull())
1813     {
1814       ais = Handle(AIS_LengthDimension)::DownCast(anAIS);
1815     }
1816
1817     if (S1.ShapeType() == TopAbs_FACE && S2.ShapeType() == TopAbs_FACE)
1818     {
1819       if (ais.IsNull())
1820       {
1821         ais = new AIS_LengthDimension (TopoDS::Face(S1),TopoDS::Face(S2));
1822       }
1823       else
1824       {
1825         ais->SetMeasuredShapes (S1, S2);
1826         ais->SetCustomValue(val1);
1827       }
1828
1829       if (is_planar)
1830       {
1831         ais->SetCustomPlane (aplane->Pln());
1832       }
1833
1834       anAIS = ais;
1835       return;
1836     }
1837     else
1838     if (S1.ShapeType() == TopAbs_EDGE && S2.ShapeType() == TopAbs_EDGE) {
1839       // Find a plane for the dimension
1840       TopoDS_Edge OE = TopoDS::Edge(S1);
1841       BRepAdaptor_Curve CURVE(OE);
1842       if (CURVE.GetType() == GeomAbs_Line)  {
1843         // Works only with line !!
1844         Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
1845         gp_Lin OLin = Handle(Geom_Line)::DownCast (aGeomGeometry)->Lin();
1846         TopoDS_Edge NE = TopoDS::Edge(S2);
1847         CURVE.Initialize (NE);
1848         aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
1849         gp_Lin NLin = Handle(Geom_Line)::DownCast (aGeomGeometry)->Lin();
1850         gp_Dir TDir (NLin.Location().XYZ() - OLin.Location().XYZ());
1851         aplane = new Geom_Plane (NLin.Location(),NLin.Direction()^TDir);
1852
1853         if (ais.IsNull()) {
1854           ais = new AIS_LengthDimension (S1,S2,aplane->Pln());
1855         }
1856         else {
1857           ais->SetMeasuredShapes (S1, S2);
1858           ais->SetCustomValue(val1);
1859
1860           ais->SetCustomPlane (aplane->Pln());
1861         }
1862         anAIS = ais;
1863         return;
1864       }
1865       else
1866       if (CURVE.GetType() == GeomAbs_Circle)  {
1867         Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
1868         gp_Ax1 ax = Handle(Geom_Circle)::DownCast (aGeomGeometry)->Circ().Axis();
1869         aplane = new Geom_Plane (ax.Location(),ax.Direction());
1870         is_planar = Standard_True;
1871       }
1872     }
1873   }
1874
1875
1876   if (!is_planar)  {
1877     if (S1.ShapeType() == TopAbs_COMPOUND && 
1878         S2.ShapeType() == TopAbs_COMPOUND)  {
1879       // Resultat d'un offset - on reconstruit un wire pour determiner un plan
1880       TopoDS_Wire w1;
1881       BRep_Builder B;
1882       B.MakeWire (w1);
1883       TopExp_Explorer exp (S1,TopAbs_EDGE);
1884       for (;exp.More();exp.Next())
1885         B.Add (w1,exp.Current());
1886
1887       BRepBuilderAPI_MakeFace MkF (w1,Standard_True);
1888       if (MkF.IsDone())  {
1889         Handle(Geom_Surface) aGeomSurface = BRep_Tool::Surface(MkF.Face());
1890         aplane = Handle(Geom_Plane)::DownCast (aGeomSurface);
1891         is_planar = Standard_True;
1892       }
1893     }
1894   }
1895
1896   if (is_planar) {
1897     ComputeTextAndValue (aConst,val1,txt,Standard_False);
1898     TopExp_Explorer EXP1 (S1,TopAbs_VERTEX);
1899     S1 = EXP1.Current();
1900     gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(S1));
1901       
1902     TopoDS_Vertex nearest;
1903     Standard_Real dist(RealLast());
1904
1905     for (TopExp_Explorer EXP2(S2,TopAbs_VERTEX); EXP2.More(); EXP2.Next()) {
1906       const TopoDS_Vertex& current = TopoDS::Vertex(EXP2.Current());
1907       gp_Pnt curpnt = BRep_Tool::Pnt(current);
1908       Standard_Real curdist = P.SquareDistance(curpnt);
1909       if (curdist < dist) {
1910         nearest= current;
1911         dist = curdist;
1912       }
1913     }
1914     S2 = nearest;
1915     ais = Handle(AIS_LengthDimension)::DownCast(anAIS);
1916     if (ais.IsNull()) {
1917       ais = new AIS_LengthDimension (S1,S2,aplane->Pln());
1918     }
1919     else {
1920       ais->SetMeasuredShapes (S1, S2);
1921       ais->SetCustomValue (val1);
1922       ais->SetCustomPlane (aplane->Pln ());
1923     }
1924     anAIS = ais;
1925     return;
1926   }
1927
1928 #ifdef OCCT_DEBUG
1929   cout << "TPrsStd_ConstraintTools::ComputeOffset: Case not implemented" << endl;
1930 #endif
1931   NullifyAIS(anAIS);
1932 }
1933
1934
1935 //=======================================================================
1936 //function : ComputePlacement
1937 //purpose  : 
1938 //=======================================================================
1939 void TPrsStd_ConstraintTools::ComputePlacement
1940 (const Handle(TDataXtd_Constraint)& aConst,
1941  Handle(AIS_InteractiveObject)& anAIS) 
1942 {
1943   Standard_Integer nbgeom = aConst->NbGeometries();
1944   if (nbgeom < 2) 
1945     throw Standard_ProgramError("TPrsStd_ConstraintTools::ComputePlacement: at leat two constraints are needed");
1946   
1947   TopoDS_Shape shape1,shape2 ;
1948   GetTwoShapes(aConst,shape1,shape2);
1949   if (shape1.IsNull() || shape2.IsNull()) {
1950 #ifdef OCCT_DEBUG
1951     cout << "TPrsStd_ConstraintTools::ComputePlacement: nul shape" << endl;
1952 #endif
1953     NullifyAIS(anAIS);
1954     return;
1955   }
1956   
1957   Standard_Real val1=0.0;
1958   TCollection_ExtendedString txt= " ";
1959   if (aConst->IsDimension()) {
1960     ComputeTextAndValue(aConst,val1,txt,Standard_False);
1961   }
1962   //  Update de l'AIS
1963   Handle(AIS_OffsetDimension) ais;
1964   if (anAIS.IsNull()) {
1965     ais = new AIS_OffsetDimension(GetFace(shape1),GetFace(shape2),val1,txt);
1966     ais->SetArrowSize(val1/20.);
1967   } else {
1968     ais = Handle(AIS_OffsetDimension)::DownCast(anAIS);
1969     if (ais.IsNull()) {
1970       ais = new AIS_OffsetDimension(GetFace(shape1),GetFace(shape2),val1,txt);
1971       ais->SetArrowSize(val1/20.);
1972     } else {
1973       ais->SetFirstShape(GetFace(shape1));
1974       ais->SetSecondShape(GetFace(shape2));
1975       ais->SetValue(val1);
1976       ais->SetText(txt);
1977       ais->SetArrowSize(val1/20.);
1978     }
1979   }
1980   if (GetFace(shape1).IsNull() || GetFace(shape2).IsNull()) ais.Nullify();
1981   anAIS = ais;
1982 }
1983
1984 //=======================================================================
1985 //function : ComputeOthers
1986 //purpose  : 
1987 //=======================================================================
1988 void TPrsStd_ConstraintTools::ComputeOthers
1989 (const Handle(TDataXtd_Constraint)& /*aConst*/,
1990  Handle(AIS_InteractiveObject)& /*anAIS*/) 
1991 {
1992 }
1993
1994 //=======================================================================
1995 //function : GetOneShape
1996 //purpose  : 
1997 //=======================================================================
1998 void TPrsStd_ConstraintTools::GetOneShape
1999 (const Handle(TDataXtd_Constraint)& aConst,
2000  TopoDS_Shape& aShape) 
2001 {
2002   const Handle(TNaming_NamedShape)& ageom1 = aConst->GetGeometry(1);
2003   if (!ageom1.IsNull()) aShape =  TNaming_Tool::CurrentShape(ageom1);
2004 }
2005
2006 //=======================================================================
2007 //function : GetTwoShapes
2008 //purpose  : 
2009 //=======================================================================
2010 void TPrsStd_ConstraintTools::GetTwoShapes
2011 (const Handle(TDataXtd_Constraint)& aConst,
2012  TopoDS_Shape& aShape1,
2013  TopoDS_Shape& aShape2) 
2014 {
2015   const Handle(TNaming_NamedShape)& ageom1 = aConst->GetGeometry(1);    
2016   if (!ageom1.IsNull()) aShape1 =  TNaming_Tool::CurrentShape(aConst->GetGeometry(1));
2017   const Handle(TNaming_NamedShape)& ageom2 = aConst->GetGeometry(2);    
2018   if (!ageom2.IsNull()) aShape2 =  TNaming_Tool::CurrentShape(aConst->GetGeometry(2));
2019 }
2020
2021 //=======================================================================
2022 //function : GetShapesAndGeom
2023 //purpose  : 
2024 //=======================================================================
2025 void TPrsStd_ConstraintTools::GetShapesAndGeom
2026 (const Handle(TDataXtd_Constraint)& aConst,
2027  TopoDS_Shape& aShape1,
2028  TopoDS_Shape& aShape2,
2029  Handle(Geom_Geometry)& aGeom) 
2030 {
2031   GetTwoShapes(aConst,aShape1,aShape2);
2032   GetGeom(aConst,aGeom);
2033 }
2034
2035 //=======================================================================
2036 //function : GetShapesAndGeom
2037 //purpose  : 
2038 //=======================================================================
2039 void TPrsStd_ConstraintTools::GetShapesAndGeom
2040 (const Handle(TDataXtd_Constraint)& aConst,
2041  TopoDS_Shape& aShape1,
2042  TopoDS_Shape& aShape2,
2043  TopoDS_Shape& aShape3,
2044  Handle(Geom_Geometry)& aGeom) 
2045 {
2046   GetTwoShapes(aConst,aShape1,aShape2);
2047   const Handle(TNaming_NamedShape)& ageom3 = aConst->GetGeometry(3);//ota: GetGeometry(2) was  
2048   if (!ageom3.IsNull()) aShape3 =  TNaming_Tool::CurrentShape(aConst->GetGeometry(3));
2049   GetGeom(aConst,aGeom);
2050 }
2051
2052 //=======================================================================
2053 //function : GetShapesAndGeom
2054 //purpose  : 
2055 //=======================================================================
2056 void TPrsStd_ConstraintTools::GetShapesAndGeom
2057   (const Handle(TDataXtd_Constraint)& aConst,
2058    TopoDS_Shape& aShape1,
2059    TopoDS_Shape& aShape2,
2060    TopoDS_Shape& aShape3,
2061    TopoDS_Shape& aShape4,
2062    Handle(Geom_Geometry)& aGeom) 
2063 {
2064   GetTwoShapes(aConst,aShape1, aShape2 );
2065   const Handle(TNaming_NamedShape)& ageom3 = aConst->GetGeometry(3);    
2066   if (!ageom3.IsNull()) aShape3 =  TNaming_Tool::CurrentShape(aConst->GetGeometry(3));
2067   const Handle(TNaming_NamedShape)& ageom4 = aConst->GetGeometry(4); 
2068   if (!ageom4.IsNull()) aShape4 =  TNaming_Tool::CurrentShape(aConst->GetGeometry(4));
2069   GetGeom(aConst,aGeom);
2070 }
2071
2072 //=======================================================================
2073 //function : ComputeCoincident
2074 //purpose  : 
2075 //=======================================================================
2076 void TPrsStd_ConstraintTools::ComputeCoincident(const Handle(TDataXtd_Constraint)& aConst,
2077                                                Handle(AIS_InteractiveObject)& anAIS) 
2078 {
2079   Standard_Integer nbgeom = aConst->NbGeometries();
2080   if (nbgeom < 2) {
2081 #ifdef OCCT_DEBUG
2082     cout << "TPrsStd_ConstraintTools::ComputeCoincident: at leat two constraintes are needed" << endl;
2083 #endif
2084     NullifyAIS(anAIS);
2085     return; 
2086   }
2087   
2088   if (!aConst->IsPlanar()) { 
2089 #ifdef OCCT_DEBUG
2090     cout << "TPrsStd_ConstraintTools::ComputeCoincident: must be a planar constraint" << endl;
2091 #endif
2092     anAIS.Nullify() ; 
2093     return;
2094   }
2095   
2096   TopoDS_Shape shape1,shape2 ;
2097   Handle(Geom_Geometry) ageom;
2098   GetShapesAndGeom(aConst,shape1,shape2,ageom);
2099   Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast (ageom);
2100   if (shape1.IsNull() || shape2.IsNull()) {
2101 #ifdef OCCT_DEBUG
2102     cout << "TPrsStd_ConstraintTools::ComputeCoincident: nul shape" << endl;
2103 #endif
2104     NullifyAIS(anAIS);
2105     return;
2106   }
2107
2108   GetGoodShape(shape1);
2109   GetGoodShape(shape2);
2110   if (aplane.IsNull()) {
2111 #ifdef OCCT_DEBUG
2112     cout << "TPrsStd_ConstraintTools::ComputeCoincident: nul plane" << endl;
2113 #endif
2114     NullifyAIS(anAIS);
2115     return;
2116   }
2117   
2118   //  Update de l'AIS
2119   Handle(AIS_IdenticRelation) ais;
2120   if (anAIS.IsNull()) ais = new AIS_IdenticRelation(shape1,shape2,aplane);
2121   else {
2122     ais = Handle(AIS_IdenticRelation)::DownCast(anAIS);
2123     if (ais.IsNull()) {
2124       ais = new AIS_IdenticRelation(shape1,shape2,aplane);
2125     }
2126     else {
2127       ais->SetFirstShape(shape1);
2128       ais->SetSecondShape(shape2);
2129       ais->SetPlane(aplane);
2130     }
2131   }
2132   anAIS = ais;
2133 }
2134
2135 //=======================================================================
2136 //function : ComputeRound
2137 //purpose  : 
2138 //=======================================================================
2139 void TPrsStd_ConstraintTools::ComputeRound(const Handle(TDataXtd_Constraint)& aConst,
2140                                                Handle(AIS_InteractiveObject)& anAIS) 
2141 {
2142   Standard_Integer nbgeom = aConst->NbGeometries();
2143   if (nbgeom < 1) {
2144 #ifdef OCCT_DEBUG
2145     cout << "TPrsStd_ConstraintTools::ComputeRound: at leat one geometry is needed" << endl;
2146 #endif
2147     NullifyAIS(anAIS);
2148     return; 
2149   }
2150   TopoDS_Shape shape1;
2151   GetOneShape (aConst,shape1);
2152   if (shape1.IsNull()) {
2153 #ifdef OCCT_DEBUG
2154     cout << "TPrsStd_ConstraintTools::ComputePlacement: nul shape" << endl;
2155 #endif
2156     NullifyAIS(anAIS);
2157     return;
2158   }
2159   
2160   Standard_Real val1;
2161   TCollection_ExtendedString txt;
2162   ComputeTextAndValue(aConst,val1,txt,Standard_False);
2163   
2164   //  Update de l'AIS
2165   Handle(AIS_RadiusDimension) ais;
2166
2167   {
2168    try {
2169      OCC_CATCH_SIGNALS
2170      if (anAIS.IsNull()) ais = 
2171        new AIS_RadiusDimension(shape1);
2172      else {
2173        ais = Handle(AIS_RadiusDimension)::DownCast(anAIS);
2174        if (ais.IsNull()) {
2175          ais = new AIS_RadiusDimension(shape1);
2176        }
2177        else {
2178          ais->SetMeasuredGeometry(shape1);
2179        }
2180      }
2181    }
2182    catch(Standard_Failure const&) {
2183      ais.Nullify();
2184    }
2185  }
2186   anAIS = ais;
2187 }
2188
2189 //=======================================================================
2190 //function : GetGeom
2191 //purpose  : 
2192 //=======================================================================
2193 void TPrsStd_ConstraintTools::GetGeom(const Handle(TDataXtd_Constraint)& aConst,
2194                                      Handle(Geom_Geometry)& aGeom)
2195 {  
2196   Handle(TNaming_NamedShape) atgeom = aConst->GetPlane();
2197   if (atgeom.IsNull()) {
2198 #ifdef OCCT_DEBUG
2199     cout<<"TPrsStd_ConstraintTools::GetGeom : aConst->GetPlane().IsNull()"<<endl;
2200 #endif
2201     return;
2202   }
2203   gp_Pln aplane;
2204   gp_Lin anaxis;
2205   gp_Pnt apoint;
2206   
2207   TDF_Label label = atgeom->Label();
2208
2209   Handle(TNaming_NamedShape) NS;
2210   if(label.FindAttribute(TNaming_NamedShape::GetID(),NS)){
2211     TopoDS_Shape s = TNaming_Tool::GetShape(NS);
2212     if(s.IsNull()) return;
2213   }
2214
2215   if (TDataXtd_Geometry::Plane(label,aplane)) aGeom =  new Geom_Plane(aplane);
2216   else if (TDataXtd_Geometry::Line(label,anaxis)) aGeom =  new Geom_Line(anaxis);
2217   else if (TDataXtd_Geometry::Point(label,apoint)) aGeom =  new Geom_CartesianPoint(apoint);
2218 #ifdef OCCT_DEBUG
2219   else {
2220     cout << "TPrsStd_ConstraintTools::GetGeom no geom on label " << endl;
2221   }
2222 #endif  
2223 }
2224