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