[occt.git] / src / PrsDim / PrsDim_ParallelRelation.cxx

// Created on: 1996-12-05
// Created by: Jean-Pierre COMBE/Odile Olivier
// Copyright (c) 1996-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <PrsDim_ParallelRelation.hxx>

#include <PrsDim.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <DsgPrs_LengthPresentation.hxx>
#include <ElCLib.hxx>
#include <gce_MakeLin.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <gp_Ax1.hxx>
#include <gp_Ax2.hxx>
#include <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt.hxx>
#include <Precision.hxx>
#include <Prs3d_ArrowAspect.hxx>
#include <Prs3d_DimensionAspect.hxx>
#include <Prs3d_Drawer.hxx>
#include <Prs3d_Presentation.hxx>
#include <Select3D_SensitiveBox.hxx>
#include <Select3D_SensitiveSegment.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <SelectMgr_Selection.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NotImplemented.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>

IMPLEMENT_STANDARD_RTTIEXT(PrsDim_ParallelRelation, PrsDim_Relation)

//=======================================================================
//function : Constructor
//purpose  : 
//=======================================================================
PrsDim_ParallelRelation::PrsDim_ParallelRelation(const TopoDS_Shape& aFShape, 
					   const TopoDS_Shape& aSShape, 
					   const Handle(Geom_Plane)& aPlane)
{
  myFShape = aFShape;
  mySShape = aSShape;
  myPlane = aPlane;
  myAutomaticPosition = Standard_True;
  myArrowSize = 0.01;
  mySymbolPrs = DsgPrs_AS_BOTHAR;
}

//=======================================================================
//function : Constructor
//purpose  : 
//=======================================================================
PrsDim_ParallelRelation::PrsDim_ParallelRelation(const TopoDS_Shape& aFShape, 
					   const TopoDS_Shape& aSShape, 
					   const Handle(Geom_Plane)& aPlane, 
					   const gp_Pnt& aPosition,
					   const DsgPrs_ArrowSide aSymbolPrs, 
					   const Standard_Real anArrowSize)
{
  myFShape = aFShape;
  mySShape = aSShape;
  myPlane = aPlane;
  myAutomaticPosition = Standard_False;
  SetArrowSize( anArrowSize );
  myPosition = aPosition;
  mySymbolPrs = aSymbolPrs;
}

//=======================================================================
//function : Compute
//purpose  : 
//=======================================================================
void PrsDim_ParallelRelation::Compute(const Handle(PrsMgr_PresentationManager3d)&, 
				   const Handle(Prs3d_Presentation)& aPresentation, 
				   const Standard_Integer)
{
  switch (myFShape.ShapeType())
    {
    case TopAbs_FACE :
      {
	// cas longueur entre deux faces
	ComputeTwoFacesParallel(aPresentation);
      }
      break;
    case TopAbs_EDGE :
      {
	// cas longueur entre deux edges
	ComputeTwoEdgesParallel(aPresentation);
      }
      break;
    default:
      break;
    }
}

//=======================================================================
//function : ComputeSelection
//purpose  : 
//=======================================================================
void PrsDim_ParallelRelation::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection, 
					    const Standard_Integer)
{
  gp_Lin L1 (myFAttach,myDirAttach);
  gp_Lin L2 (mySAttach,myDirAttach);
  gp_Pnt Proj1 = ElCLib::Value(ElCLib::Parameter(L1,myPosition),L1);
  gp_Pnt Proj2 = ElCLib::Value(ElCLib::Parameter(L2,myPosition),L2);
  
  gp_Lin L3;
  Handle(SelectMgr_EntityOwner) own = new SelectMgr_EntityOwner(this,7);

  if (!Proj1.IsEqual(Proj2,Precision::Confusion()))
    {
      L3 = gce_MakeLin(Proj1,Proj2);
    }
  else
    {
      L3 = gce_MakeLin(Proj1,myDirAttach);
      Standard_Real size(Min(myVal/100.+1.e-6,myArrowSize+1.e-6));
      Handle(Select3D_SensitiveBox) box =
	new Select3D_SensitiveBox(own,
				  myPosition.X(),
				  myPosition.Y(),
				  myPosition.Z(),
				  myPosition.X()+size,
				  myPosition.Y()+size,
				  myPosition.Z()+size);
      aSelection->Add(box);
    }
  Standard_Real parmin,parmax,parcur;
  parmin = ElCLib::Parameter(L3,Proj1);
  parmax = parmin;
  
  parcur = ElCLib::Parameter(L3,Proj2);
  parmin = Min(parmin,parcur);
  parmax = Max(parmax,parcur);
  
  parcur = ElCLib::Parameter(L3,myPosition);
  parmin = Min(parmin,parcur);
  parmax = Max(parmax,parcur);
  
  gp_Pnt PointMin = ElCLib::Value(parmin,L3);
  gp_Pnt PointMax = ElCLib::Value(parmax,L3);

  Handle(Select3D_SensitiveSegment) seg;
  
  if (!PointMin.IsEqual(PointMax,Precision::Confusion()))
    {
      seg = new Select3D_SensitiveSegment(own,
					  PointMin,
					  PointMax);
      aSelection->Add(seg);
    }
  if (!myFAttach.IsEqual(Proj1,Precision::Confusion()))
    {
      seg = new Select3D_SensitiveSegment(own, myFAttach, Proj1);
      aSelection->Add(seg);
    }
  if (!mySAttach.IsEqual(Proj2,Precision::Confusion()))
    {
      seg = new Select3D_SensitiveSegment(own, mySAttach, Proj2);
      aSelection->Add(seg);
    }
}

//=======================================================================
//function : ComputeTwoFacesParallel
//purpose  : 
//=======================================================================
void PrsDim_ParallelRelation::ComputeTwoFacesParallel(const Handle(Prs3d_Presentation)&)
{
  throw Standard_NotImplemented("PrsDim_ParallelRelation::ComputeTwoFacesParallel not implemented");
}

//=======================================================================
//function : ComputeTwoEdgesParallel
//purpose  : 
//=======================================================================
void PrsDim_ParallelRelation::ComputeTwoEdgesParallel(const Handle(Prs3d_Presentation)& aPresentation)
{
  TopoDS_Edge E1 = TopoDS::Edge(myFShape);
  TopoDS_Edge E2 = TopoDS::Edge(mySShape);

  gp_Pnt ptat11,ptat12,ptat21,ptat22;//,pint3d;
  Handle(Geom_Curve) geom1,geom2;
  Standard_Boolean isInfinite1,isInfinite2;
  Handle(Geom_Curve) extCurv;
  if (!PrsDim::ComputeGeometry(E1,E2,myExtShape,
			    geom1,geom2,
			    ptat11,ptat12,ptat21,ptat22,
			    extCurv,
			    isInfinite1,isInfinite2,
			    myPlane))
    {
      return;
    }

  aPresentation->SetInfiniteState((isInfinite1 || isInfinite2) && (myExtShape != 0));

  gp_Lin l1;
  gp_Lin l2;
  Standard_Boolean isEl1 = Standard_False, isEl2 = Standard_False;

  if (geom1->IsInstance(STANDARD_TYPE(Geom_Ellipse)))
    {
      Handle(Geom_Ellipse) geom_el1 (Handle(Geom_Ellipse)::DownCast (geom1));
      // construct lines through focuses
      gp_Ax1 elAx = geom_el1->XAxis();
      l1 = gp_Lin(elAx);
      Standard_Real focex = geom_el1->MajorRadius() - geom_el1->Focal()/2.0;
      gp_Vec transvec = gp_Vec(elAx.Direction())*focex;
      ptat11 = geom_el1->Focus1().Translated(transvec);
      ptat12 = geom_el1->Focus2().Translated(-transvec);
      isEl1 = Standard_True;
    }
  else if (geom1->IsInstance(STANDARD_TYPE(Geom_Line)))
    {
      Handle(Geom_Line) geom_lin1 (Handle(Geom_Line)::DownCast (geom1));
      l1 = geom_lin1->Lin();
    }
  else return;

  if (geom2->IsInstance(STANDARD_TYPE(Geom_Ellipse)))
    {
      Handle(Geom_Ellipse) geom_el2 (Handle(Geom_Ellipse)::DownCast (geom2));
      // construct lines through focuses
      gp_Ax1 elAx = geom_el2->XAxis();
      l2 = gp_Lin(elAx);
      Standard_Real focex = geom_el2->MajorRadius() - geom_el2->Focal()/2.0;
      gp_Vec transvec = gp_Vec(elAx.Direction())*focex;
      ptat21 = geom_el2->Focus1().Translated(transvec);
      ptat22 = geom_el2->Focus2().Translated(-transvec);
      isEl2 = Standard_True;
    }
  else if (geom2->IsInstance(STANDARD_TYPE(Geom_Line)))
    {
      Handle(Geom_Line) geom_lin2 (Handle(Geom_Line)::DownCast (geom2));
      l2 = geom_lin2->Lin();
    }
  else return;

  const Handle(Geom_Line)& geom_lin1 = new Geom_Line(l1);
  const Handle(Geom_Line)& geom_lin2 = new Geom_Line(l2);

  myDirAttach = l1.Direction();
  // size
  if( !myArrowSizeIsDefined ) {
    Standard_Real arrSize1 (myArrowSize), arrSize2 (myArrowSize);
    if (!isInfinite1) arrSize1 = ptat11.Distance(ptat12)/50.;
    if (!isInfinite2) arrSize2 = ptat21.Distance(ptat22)/50.;
    myArrowSize = Max(myArrowSize,Max(arrSize1,arrSize2));
//  myArrowSize = Min(myArrowSize,Min(arrSize1,arrSize2));
  }

  if ( myAutomaticPosition )
    {    
      gp_Pnt curpos;
      if ( !isInfinite1 )
	{
	  gp_Pnt p2 = ElCLib::Value(ElCLib::Parameter(l2,ptat11),l2);
	  curpos.SetXYZ((ptat11.XYZ() + p2.XYZ())/2.);
	}
      else if ( !isInfinite2 )
	{
	  gp_Pnt p2 = ElCLib::Value(ElCLib::Parameter(l1,ptat21),l1);
	  curpos.SetXYZ((ptat21.XYZ()+p2.XYZ())/2.);
	}
      else
	{
	  curpos.SetXYZ((l1.Location().XYZ()+l2.Location().XYZ())/2.);
	}
      // offset pour eviter confusion Edge et Dimension
      gp_Vec offset (myDirAttach);
      offset = offset*myArrowSize*(-10.);
      curpos.Translate(offset);
      myPosition = curpos;
    }

  // recherche points attache
  if (!isInfinite1)
    {
      if ( isEl1 )
	{
	  if (myPosition.Distance(ptat11) < myPosition.Distance(ptat12)) myFAttach = ptat12;
	  else myFAttach = ptat11;
	}
      else
	{
	  if (myPosition.Distance(ptat11) > myPosition.Distance(ptat12)) myFAttach = ptat12;
	  else myFAttach = ptat11;
	}
    }
  else
    {
      myFAttach = ElCLib::Value(ElCLib::Parameter(l1,myPosition),l1);
    }
  
  if (!isInfinite2)
    {
      if ( isEl2 )
	{
	  if (myPosition.Distance(ptat21) < myPosition.Distance(ptat22)) mySAttach = ptat22;
	  else mySAttach = ptat21;
	}
      else
	{
	  if (myPosition.Distance(ptat21) > myPosition.Distance(ptat22)) mySAttach = ptat22;
	  else mySAttach = ptat21;
	}
    }
  else
    {
      mySAttach = ElCLib::Value(ElCLib::Parameter(l2,myPosition),l2);
    }
  TCollection_ExtendedString aText (" //");
  
  if (l1.Distance(l2) <= Precision::Confusion())
    {
      myArrowSize = 0.;
    }
  Handle(Prs3d_DimensionAspect) la = myDrawer->DimensionAspect();
  Handle(Prs3d_ArrowAspect) arr = la->ArrowAspect();
  arr->SetLength(myArrowSize);
  arr = la->ArrowAspect();
  arr->SetLength(myArrowSize);
  if ( myExtShape == 1)
    mySymbolPrs = DsgPrs_AS_FIRSTPT_LASTAR;
  else if ( myExtShape == 2)
    mySymbolPrs = DsgPrs_AS_FIRSTAR_LASTPT;

  DsgPrs_LengthPresentation::Add(aPresentation,
				 myDrawer,
				 aText,
				 myFAttach,
				 mySAttach,
				 myDirAttach,
				 myPosition,
				 mySymbolPrs);
  if ( (myExtShape != 0) &&  !extCurv.IsNull())
    {
      gp_Pnt pf, pl;
      if ( myExtShape == 1 )
	{
	  if (!isInfinite1)
	    {
	      pf = ptat11; 
	      pl = ptat12;
	    }
	  ComputeProjEdgePresentation(aPresentation,E1,geom_lin1,pf,pl);
	}
      else
	{
	  if (!isInfinite2)
	    {
	      pf = ptat21; 
	      pl = ptat22;
	    }
	  ComputeProjEdgePresentation(aPresentation,E2,geom_lin2,pf,pl);
	}
    }
}
Commit	Line	Data
b311480e	1	// Created on: 1996-12-05
	2	// Created by: Jean-Pierre COMBE/Odile Olivier
	3	// Copyright (c) 1996-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
787ff240	17	#include <PrsDim_ParallelRelation.hxx>
7fd59977	18
787ff240	19	#include <PrsDim.hxx>
7fd59977	20	#include <BRep_Tool.hxx>
7fd59977	21	#include <BRepAdaptor_Curve.hxx>
42cf5bc1	22	#include <BRepAdaptor_Surface.hxx>
42cf5bc1	23	#include <DsgPrs_LengthPresentation.hxx>
7fd59977	24	#include <ElCLib.hxx>
7fd59977	25	#include <gce_MakeLin.hxx>
7fd59977	26	#include <Geom_Ellipse.hxx>
42cf5bc1	27	#include <Geom_Line.hxx>
42cf5bc1	28	#include <Geom_Plane.hxx>
42cf5bc1	29	#include <gp_Ax1.hxx>
	30	#include <gp_Ax2.hxx>
	31	#include <gp_Dir.hxx>
	32	#include <gp_Lin.hxx>
	33	#include <gp_Pln.hxx>
	34	#include <gp_Pnt.hxx>
	35	#include <Precision.hxx>
	36	#include <Prs3d_ArrowAspect.hxx>
	37	#include <Prs3d_DimensionAspect.hxx>
	38	#include <Prs3d_Drawer.hxx>
	39	#include <Prs3d_Presentation.hxx>
42cf5bc1	40	#include <Select3D_SensitiveBox.hxx>
	41	#include <Select3D_SensitiveSegment.hxx>
	42	#include <SelectMgr_EntityOwner.hxx>
	43	#include <SelectMgr_Selection.hxx>
	44	#include <Standard_DomainError.hxx>
	45	#include <Standard_NotImplemented.hxx>
42cf5bc1	46	#include <TCollection_AsciiString.hxx>
42cf5bc1	47	#include <TCollection_ExtendedString.hxx>
42cf5bc1	48	#include <TopoDS.hxx>
42cf5bc1	49	#include <TopoDS_Shape.hxx>
7fd59977	50
787ff240	51	IMPLEMENT_STANDARD_RTTIEXT(PrsDim_ParallelRelation, PrsDim_Relation)
92efcf78	52
7fd59977	53	//=======================================================================
	54	//function : Constructor
	55	//purpose :
	56	//=======================================================================
787ff240	57	PrsDim_ParallelRelation::PrsDim_ParallelRelation(const TopoDS_Shape& aFShape,
7fd59977	58	const TopoDS_Shape& aSShape,
	59	const Handle(Geom_Plane)& aPlane)
	60	{
	61	myFShape = aFShape;
	62	mySShape = aSShape;
	63	myPlane = aPlane;
	64	myAutomaticPosition = Standard_True;
	65	myArrowSize = 0.01;
	66	mySymbolPrs = DsgPrs_AS_BOTHAR;
	67	}
	68
	69	//=======================================================================
	70	//function : Constructor
	71	//purpose :
	72	//=======================================================================
787ff240	73	PrsDim_ParallelRelation::PrsDim_ParallelRelation(const TopoDS_Shape& aFShape,
7fd59977	74	const TopoDS_Shape& aSShape,
	75	const Handle(Geom_Plane)& aPlane,
	76	const gp_Pnt& aPosition,
	77	const DsgPrs_ArrowSide aSymbolPrs,
	78	const Standard_Real anArrowSize)
	79	{
	80	myFShape = aFShape;
	81	mySShape = aSShape;
	82	myPlane = aPlane;
	83	myAutomaticPosition = Standard_False;
7fd59977	84	SetArrowSize( anArrowSize );
7fd59977	85	myPosition = aPosition;
	86	mySymbolPrs = aSymbolPrs;
	87	}
	88
	89	//=======================================================================
	90	//function : Compute
	91	//purpose :
	92	//=======================================================================
787ff240	93	void PrsDim_ParallelRelation::Compute(const Handle(PrsMgr_PresentationManager3d)&,
7fd59977	94	const Handle(Prs3d_Presentation)& aPresentation,
	95	const Standard_Integer)
	96	{
7fd59977	97	switch (myFShape.ShapeType())
	98	{
	99	case TopAbs_FACE :
	100	{
	101	// cas longueur entre deux faces
	102	ComputeTwoFacesParallel(aPresentation);
	103	}
	104	break;
	105	case TopAbs_EDGE :
	106	{
	107	// cas longueur entre deux edges
	108	ComputeTwoEdgesParallel(aPresentation);
	109	}
	110	break;
	111	default:
	112	break;
	113	}
	114	}
	115
7fd59977	116	//=======================================================================
	117	//function : ComputeSelection
	118	//purpose :
	119	//=======================================================================
787ff240	120	void PrsDim_ParallelRelation::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
7fd59977	121	const Standard_Integer)
	122	{
	123	gp_Lin L1 (myFAttach,myDirAttach);
	124	gp_Lin L2 (mySAttach,myDirAttach);
	125	gp_Pnt Proj1 = ElCLib::Value(ElCLib::Parameter(L1,myPosition),L1);
	126	gp_Pnt Proj2 = ElCLib::Value(ElCLib::Parameter(L2,myPosition),L2);
	127
	128	gp_Lin L3;
	129	Handle(SelectMgr_EntityOwner) own = new SelectMgr_EntityOwner(this,7);
	130
	131	if (!Proj1.IsEqual(Proj2,Precision::Confusion()))
	132	{
	133	L3 = gce_MakeLin(Proj1,Proj2);
	134	}
	135	else
	136	{
	137	L3 = gce_MakeLin(Proj1,myDirAttach);
	138	Standard_Real size(Min(myVal/100.+1.e-6,myArrowSize+1.e-6));
	139	Handle(Select3D_SensitiveBox) box =
	140	new Select3D_SensitiveBox(own,
	141	myPosition.X(),
	142	myPosition.Y(),
	143	myPosition.Z(),
	144	myPosition.X()+size,
	145	myPosition.Y()+size,
	146	myPosition.Z()+size);
	147	aSelection->Add(box);
	148	}
	149	Standard_Real parmin,parmax,parcur;
	150	parmin = ElCLib::Parameter(L3,Proj1);
	151	parmax = parmin;
	152
	153	parcur = ElCLib::Parameter(L3,Proj2);
	154	parmin = Min(parmin,parcur);
	155	parmax = Max(parmax,parcur);
	156
	157	parcur = ElCLib::Parameter(L3,myPosition);
	158	parmin = Min(parmin,parcur);
	159	parmax = Max(parmax,parcur);
	160
	161	gp_Pnt PointMin = ElCLib::Value(parmin,L3);
	162	gp_Pnt PointMax = ElCLib::Value(parmax,L3);
	163
	164	Handle(Select3D_SensitiveSegment) seg;
	165
	166	if (!PointMin.IsEqual(PointMax,Precision::Confusion()))
	167	{
	168	seg = new Select3D_SensitiveSegment(own,
	169	PointMin,
	170	PointMax);
	171	aSelection->Add(seg);
	172	}
	173	if (!myFAttach.IsEqual(Proj1,Precision::Confusion()))
	174	{
	175	seg = new Select3D_SensitiveSegment(own, myFAttach, Proj1);
	176	aSelection->Add(seg);
	177	}
	178	if (!mySAttach.IsEqual(Proj2,Precision::Confusion()))
	179	{
	180	seg = new Select3D_SensitiveSegment(own, mySAttach, Proj2);
	181	aSelection->Add(seg);
	182	}
	183	}
	184
185	//=======================================================================
186	//function : ComputeTwoFacesParallel
187	//purpose :
188	//=======================================================================
787ff240	189	void PrsDim_ParallelRelation::ComputeTwoFacesParallel(const Handle(Prs3d_Presentation)&)
7fd59977	190	{
787ff240	191	throw Standard_NotImplemented("PrsDim_ParallelRelation::ComputeTwoFacesParallel not implemented");
7fd59977	192	}
	193
	194	//=======================================================================
	195	//function : ComputeTwoEdgesParallel
	196	//purpose :
	197	//=======================================================================
787ff240	198	void PrsDim_ParallelRelation::ComputeTwoEdgesParallel(const Handle(Prs3d_Presentation)& aPresentation)
7fd59977	199	{
	200	TopoDS_Edge E1 = TopoDS::Edge(myFShape);
	201	TopoDS_Edge E2 = TopoDS::Edge(mySShape);
	202
	203	gp_Pnt ptat11,ptat12,ptat21,ptat22;//,pint3d;
	204	Handle(Geom_Curve) geom1,geom2;
	205	Standard_Boolean isInfinite1,isInfinite2;
	206	Handle(Geom_Curve) extCurv;
787ff240	207	if (!PrsDim::ComputeGeometry(E1,E2,myExtShape,
7fd59977	208	geom1,geom2,
	209	ptat11,ptat12,ptat21,ptat22,
	210	extCurv,
	211	isInfinite1,isInfinite2,
	212	myPlane))
	213	{
	214	return;
	215	}
	216
	217	aPresentation->SetInfiniteState((isInfinite1 \|\| isInfinite2) && (myExtShape != 0));
	218
	219	gp_Lin l1;
	220	gp_Lin l2;
	221	Standard_Boolean isEl1 = Standard_False, isEl2 = Standard_False;
	222
	223	if (geom1->IsInstance(STANDARD_TYPE(Geom_Ellipse)))
	224	{
c5f3a425	225	Handle(Geom_Ellipse) geom_el1 (Handle(Geom_Ellipse)::DownCast (geom1));
7fd59977	226	// construct lines through focuses
	227	gp_Ax1 elAx = geom_el1->XAxis();
	228	l1 = gp_Lin(elAx);
	229	Standard_Real focex = geom_el1->MajorRadius() - geom_el1->Focal()/2.0;
	230	gp_Vec transvec = gp_Vec(elAx.Direction())*focex;
	231	ptat11 = geom_el1->Focus1().Translated(transvec);
	232	ptat12 = geom_el1->Focus2().Translated(-transvec);
	233	isEl1 = Standard_True;
	234	}
	235	else if (geom1->IsInstance(STANDARD_TYPE(Geom_Line)))
	236	{
c5f3a425	237	Handle(Geom_Line) geom_lin1 (Handle(Geom_Line)::DownCast (geom1));
7fd59977	238	l1 = geom_lin1->Lin();
	239	}
	240	else return;
	241
	242	if (geom2->IsInstance(STANDARD_TYPE(Geom_Ellipse)))
	243	{
c5f3a425	244	Handle(Geom_Ellipse) geom_el2 (Handle(Geom_Ellipse)::DownCast (geom2));
7fd59977	245	// construct lines through focuses
	246	gp_Ax1 elAx = geom_el2->XAxis();
	247	l2 = gp_Lin(elAx);
	248	Standard_Real focex = geom_el2->MajorRadius() - geom_el2->Focal()/2.0;
	249	gp_Vec transvec = gp_Vec(elAx.Direction())*focex;
	250	ptat21 = geom_el2->Focus1().Translated(transvec);
	251	ptat22 = geom_el2->Focus2().Translated(-transvec);
	252	isEl2 = Standard_True;
	253	}
	254	else if (geom2->IsInstance(STANDARD_TYPE(Geom_Line)))
	255	{
c5f3a425	256	Handle(Geom_Line) geom_lin2 (Handle(Geom_Line)::DownCast (geom2));
7fd59977	257	l2 = geom_lin2->Lin();
	258	}
	259	else return;
	260
	261	const Handle(Geom_Line)& geom_lin1 = new Geom_Line(l1);
	262	const Handle(Geom_Line)& geom_lin2 = new Geom_Line(l2);
	263
	264	myDirAttach = l1.Direction();
	265	// size
7fd59977	266	if( !myArrowSizeIsDefined ) {
7fd59977	267	Standard_Real arrSize1 (myArrowSize), arrSize2 (myArrowSize);
	268	if (!isInfinite1) arrSize1 = ptat11.Distance(ptat12)/50.;
	269	if (!isInfinite2) arrSize2 = ptat21.Distance(ptat22)/50.;
	270	myArrowSize = Max(myArrowSize,Max(arrSize1,arrSize2));
	271	// myArrowSize = Min(myArrowSize,Min(arrSize1,arrSize2));
7fd59977	272	}
7fd59977	273
	274	if ( myAutomaticPosition )
	275	{
	276	gp_Pnt curpos;
	277	if ( !isInfinite1 )
	278	{
	279	gp_Pnt p2 = ElCLib::Value(ElCLib::Parameter(l2,ptat11),l2);
	280	curpos.SetXYZ((ptat11.XYZ() + p2.XYZ())/2.);
	281	}
	282	else if ( !isInfinite2 )
	283	{
	284	gp_Pnt p2 = ElCLib::Value(ElCLib::Parameter(l1,ptat21),l1);
	285	curpos.SetXYZ((ptat21.XYZ()+p2.XYZ())/2.);
	286	}
	287	else
	288	{
	289	curpos.SetXYZ((l1.Location().XYZ()+l2.Location().XYZ())/2.);
	290	}
	291	// offset pour eviter confusion Edge et Dimension
	292	gp_Vec offset (myDirAttach);
	293	offset = offsetmyArrowSize(-10.);
	294	curpos.Translate(offset);
	295	myPosition = curpos;
	296	}
	297
	298	// recherche points attache
	299	if (!isInfinite1)
	300	{
	301	if ( isEl1 )
	302	{
	303	if (myPosition.Distance(ptat11) < myPosition.Distance(ptat12)) myFAttach = ptat12;
	304	else myFAttach = ptat11;
	305	}
	306	else
	307	{
	308	if (myPosition.Distance(ptat11) > myPosition.Distance(ptat12)) myFAttach = ptat12;
	309	else myFAttach = ptat11;
	310	}
	311	}
	312	else
	313	{
	314	myFAttach = ElCLib::Value(ElCLib::Parameter(l1,myPosition),l1);
	315	}
	316
	317	if (!isInfinite2)
	318	{
	319	if ( isEl2 )
	320	{
	321	if (myPosition.Distance(ptat21) < myPosition.Distance(ptat22)) mySAttach = ptat22;
	322	else mySAttach = ptat21;
	323	}
	324	else
	325	{
	326	if (myPosition.Distance(ptat21) > myPosition.Distance(ptat22)) mySAttach = ptat22;
	327	else mySAttach = ptat21;
	328	}
	329	}
	330	else
	331	{
	332	mySAttach = ElCLib::Value(ElCLib::Parameter(l2,myPosition),l2);
	333	}
	334	TCollection_ExtendedString aText (" //");
	335
	336	if (l1.Distance(l2) <= Precision::Confusion())
337	{
338	myArrowSize = 0.;
339	}
a6eb515f	340	Handle(Prs3d_DimensionAspect) la = myDrawer->DimensionAspect();
a6eb515f	341	Handle(Prs3d_ArrowAspect) arr = la->ArrowAspect();
7fd59977	342	arr->SetLength(myArrowSize);
a6eb515f	343	arr = la->ArrowAspect();
7fd59977	344	arr->SetLength(myArrowSize);
	345	if ( myExtShape == 1)
	346	mySymbolPrs = DsgPrs_AS_FIRSTPT_LASTAR;
	347	else if ( myExtShape == 2)
	348	mySymbolPrs = DsgPrs_AS_FIRSTAR_LASTPT;
	349
	350	DsgPrs_LengthPresentation::Add(aPresentation,
	351	myDrawer,
	352	aText,
	353	myFAttach,
	354	mySAttach,
	355	myDirAttach,
	356	myPosition,
	357	mySymbolPrs);
	358	if ( (myExtShape != 0) && !extCurv.IsNull())
	359	{
	360	gp_Pnt pf, pl;
	361	if ( myExtShape == 1 )
	362	{
	363	if (!isInfinite1)
	364	{
	365	pf = ptat11;
	366	pl = ptat12;
	367	}
	368	ComputeProjEdgePresentation(aPresentation,E1,geom_lin1,pf,pl);
	369	}
	370	else
	371	{
	372	if (!isInfinite2)
	373	{
	374	pf = ptat21;
	375	pl = ptat22;
	376	}
	377	ComputeProjEdgePresentation(aPresentation,E2,geom_lin2,pf,pl);
	378	}
	379	}
	380	}