[occt.git] / src / StepToTopoDS / StepToTopoDS_TranslateEdge.cxx

// Created on: 1995-01-03
// Created by: Frederic MAUPAS
// Copyright (c) 1995-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.

//:o0 abv 16.02.99: POLYLINE allowed as 3d curve of edge
//gka,abv 05.04.99: S4136: improving tolerance management, eliminate BRepAPI::Precision()

#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepLib.hxx>
#include <BRepLib_MakeEdge.hxx>
#include <GCPnts_AbscissaPoint.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_CartesianPoint.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Line.hxx>
#include <Geom_Surface.hxx>
#include <GeomAbs_Shape.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <ShapeAnalysis_Curve.hxx>
#include <ShapeConstruct_Curve.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Curve.hxx>
#include <StepGeom_Pcurve.hxx>
#include <StepGeom_Polyline.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepShape_Edge.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepShape_OrientedEdge.hxx>
#include <StepShape_Vertex.hxx>
#include <StepShape_VertexPoint.hxx>
#include <StepToGeom.hxx>
#include <StepToTopoDS.hxx>
#include <StepToTopoDS_GeometricTool.hxx>
#include <StepToTopoDS_NMTool.hxx>
#include <StepToTopoDS_Tool.hxx>
#include <StepToTopoDS_TranslateEdge.hxx>
#include <StepToTopoDS_TranslateVertex.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <Transfer_TransientProcess.hxx>
#include <UnitsMethods.hxx>
#include <Standard_Failure.hxx>

//#include <StepGeom_Polyline.hxx>
//#include <TransferBRep.hxx>
//:d8
// Used in I-DEAS-like STP processing (ssv; 15.11.2010)
//#define DEBUG
// ============================================================================
// Method  : DecodeMakeEdgeError
// Purpose : 
// ============================================================================
static void DecodeMakeEdgeError(const BRepLib_MakeEdge&   ME,
				const Handle(Standard_Transient)& orig,
				const Handle(Geom_Curve)& myCurve,
				const TopoDS_Vertex&      V1,
				const TopoDS_Vertex&      V2,
				const Standard_Real&      U1,
				const Standard_Real&      U2,
				StepToTopoDS_Tool&   aTool,
				const Handle(StepShape_TopologicalRepresentationItem)& /*tobind*/)
{
  (void)U1, (void)U2; // avoid compiler warning

  Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();

#ifdef OCCT_DEBUG
  cout << "------------------------------------" << endl;
  cout << "MakeEdge Error  : " << ME.Error()<<" - ";
#endif
  switch(ME.Error())
    {
    case (BRepLib_EdgeDone): return;
    case (BRepLib_PointProjectionFailed):
      TP->AddFail(orig," Point Projection failed");
      break;
    case (BRepLib_ParameterOutOfRange):
      TP->AddFail(orig," Parameter Out Of Range");
      break;
    case (BRepLib_DifferentPointsOnClosedCurve):
      TP->AddFail(orig," Different Points on Closed Curve");
      break;
    case (BRepLib_PointWithInfiniteParameter):
      TP->AddFail(orig," Point with infinite Parameter");
      break;
    case (BRepLib_DifferentsPointAndParameter):
      if (!ShapeConstruct_Curve().AdjustCurve
	  (myCurve,BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2),Standard_True,Standard_True))
	TP->AddFail(orig," Different Points and Parameters");
       else TP->AddWarning(orig,"Different Points and Parameters, adjusted");
      break;
    case (BRepLib_LineThroughIdenticPoints):
      TP->AddFail(orig," Line through identic Points");
      break;
    }
#ifdef OCCT_DEBUG
  cout << "Original Type   : " << orig->DynamicType() << endl;
  cout << "3D Curve Type   : " << myCurve->DynamicType() << endl;
  cout << "First Parameter : " << U1 << endl;
  gp_Pnt p1 = BRep_Tool::Pnt(V1);
//  cout << "First Point     : ";
  cout << "First Vertex    : "<<p1.X()<<"  "<<p1.Y()<<"  "<<p1.Z()<<"  ";
  cout << "Distance Point - Vertex : ";
  Standard_Real d1 = p1.Distance(myCurve->Value(U1)); 
  cout << d1 << endl;
  cout << "Last  Parameter : " << U2 << endl;
  gp_Pnt p2 = BRep_Tool::Pnt(V2);
//  cout << "Last  Point     : ";
  cout << "Last  Vertex    : "<<p2.X()<<"  "<<p2.Y()<<"  "<<p2.Z()<<"  ";
  cout << "Distance Point - Vertex : ";
  Standard_Real d2 = BRep_Tool::Pnt(V2).Distance(myCurve->Value(U2)); 
  cout << d2 << endl;
#endif
}

// ============================================================================
// Method  : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge
// Purpose : Empty Constructor
// ============================================================================

static Handle(Geom_Curve) MakeCurve
  (const Handle(StepGeom_Curve)& C1, const Handle(Transfer_TransientProcess) TP)
{
  Handle(Geom_Curve) C2 = Handle(Geom_Curve)::DownCast (TP->FindTransient(C1));
  if (!C2.IsNull()) return C2;
  C2 = StepToGeom::MakeCurve (C1);
  if (! C2.IsNull())
    TP->BindTransient (C1,C2);
  return C2;
}

static TopoDS_Edge  MakeEdge
  (const Handle(Geom_Curve)& C3D,
   const TopoDS_Vertex& V1, const TopoDS_Vertex& V2,
   const Standard_Real U1, const Standard_Real U2)
{
  BRep_Builder B;
  TopoDS_Edge E;
  B.MakeEdge (E,C3D,Precision::Confusion());
  B.Add (E,V1);  B.Add (E,V2);
  B.UpdateVertex(V1, U1, E, 0.);
  B.UpdateVertex(V2, U2, E, 0.);
  return E;
}

// ============================================================================
// Method  : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
// Purpose : 
// ============================================================================

StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
{
  done = Standard_False;
}

// ============================================================================
// Method  : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
// Purpose : Constructor with an Edge and a Tool
// ============================================================================

StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge(const Handle(StepShape_Edge)& E, 
                                                       StepToTopoDS_Tool& T, 
                                                       StepToTopoDS_NMTool& NMTool)
{
  Init(E, T, NMTool);
}

// ============================================================================
// Method  : Init
// Purpose : Init with an Edge and a Tool.
//           This method builds an Edge With 2 Vertices and 2 Parameters.
//           The Edge is always build like FORWARD (BRepLib_MakeEdge)
// ============================================================================

void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge, 
                                      StepToTopoDS_Tool& aTool,
                                      StepToTopoDS_NMTool& NMTool)
{
  Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();

  Handle(StepShape_OrientedEdge) OE = 
    Handle(StepShape_OrientedEdge)::DownCast(aEdge);
  Handle(StepShape_Edge) wEdge = aEdge;
  if ( ! OE.IsNull() ) wEdge = OE->EdgeElement();
  Handle(StepShape_EdgeCurve) EC = Handle(StepShape_EdgeCurve)::DownCast(wEdge);
  
  if (aTool.IsBound(EC)) {
    myResult = aTool.Find(EC);
    if (BRep_Tool::Degenerated(TopoDS::Edge(myResult))) {
      TP->AddWarning(EC,"Degenerated Edge in several faces : transferred for each face");
    }
    else {
      myError  = StepToTopoDS_TranslateEdgeDone;
      done     = Standard_True;
//:S4136      B.SameRange(TopoDS::Edge(myResult), Standard_False);    //:a5 abv 11 Feb 98
//:S4136      B.SameParameter(TopoDS::Edge(myResult), Standard_False);//:a5
      return;
    }
  }

  // [BEGIN] Proceed with non-manifold cases (ssv; 12.11.2010)
  if ( NMTool.IsActive() && NMTool.IsBound(EC) ) {
    TopoDS_Shape existingShape = NMTool.Find(EC);
    // Reverse shape's orientation if needed
    if ( !OE->Orientation() )
      existingShape.Reverse();
    myResult = existingShape;
    myError = StepToTopoDS_TranslateEdgeDone;
    done = Standard_True;
    return;
  }
  // [END] Proceed with non-manifold cases (ssv; 12.11.2010)

  // [BEGIN] Proceed with I-DEAS-like STP (ssv; 15.11.2010)
  const Handle(TCollection_HAsciiString) anECName = EC->Name();
  if ( NMTool.IsIDEASCase() && !anECName.IsNull() && !anECName->IsEmpty() &&
       NMTool.IsBound(anECName->String()) ) {
    TopoDS_Shape existingShape = NMTool.Find(anECName->String());
    // Reverse shape's orientation if needed
    if ( !OE->Orientation() )
      existingShape.Reverse();
    // Register Edge for final processing (I-DEAS case)
    NMTool.RegisterNMEdge(existingShape);
    myResult = existingShape;
    myError = StepToTopoDS_TranslateEdgeDone;
    done = Standard_True;
    return;
  }
  // [END] Proceed with I-DEAS-like STP (ssv; 15.11.2010)

  BRep_Builder B;

  Handle(StepGeom_Curve) C = EC->EdgeGeometry();
  if( C.IsNull())
  {
    TP->AddFail(EC," Geom Curve in EdgeCurve is equal to 0");
    myError = StepToTopoDS_TranslateEdgeOther;
    done = Standard_False;
    return;
  }
  TopoDS_Edge E;
  Handle(StepShape_Vertex) Vstart, Vend;

  // -----------------------------------------------------------
  // Extract the start and end Vertices corresponding to FORWARD
  // (following the geometrical sense)
  // -----------------------------------------------------------

  Standard_Boolean EdgeCurveSameSense = EC->SameSense();
  
  if (EdgeCurveSameSense) {
    Vstart = EC->EdgeStart();
    Vend   = EC->EdgeEnd();
  }
  else {
    Vend   = EC->EdgeStart();
    Vstart = EC->EdgeEnd();
  }

  TopoDS_Vertex V1, V2;

  StepToTopoDS_TranslateVertex myTranVertex1(Vstart, aTool, NMTool);
  StepToTopoDS_TranslateVertex myTranVertex2(Vend, aTool, NMTool);

  if (myTranVertex1.IsDone()) {
    V1 = TopoDS::Vertex(myTranVertex1.Value());
    V1.Orientation(TopAbs_FORWARD);
  }
  if (Vend == Vstart) {
    V2 = V1;
    V2.Orientation(TopAbs_REVERSED);
  }
  else if (myTranVertex2.IsDone()) {
    V2 = TopoDS::Vertex(myTranVertex2.Value());
    V2.Orientation(TopAbs_REVERSED);
  }
  done = Standard_True;
  
  // ----------------------------------------------------------
  // --- The EdgeCurve Geometry is of StepGeom_Curve Type
  // --- It can be : * a Pcurve : no 3D curve is constructed
  // ---             * a Surface Curve, Intersection Curve
  // ---               or a Seam Curve
  // ---             * a 3D Curve
  // ----------------------------------------------------------
  
  if ( C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
    B.MakeEdge(E);
//:S4136    B.UpdateEdge (E,preci);
    B.Add(E, V1);
    B.Add(E, V2);
  }
  else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)) ) {
    // For SeamCurve and IntersectionCurve types
    // --- The Edge Geometry is a Surface Curve ---
    // ---     (3d + 2 Pcurve Or Surface)       ---
    Handle(StepGeom_SurfaceCurve) Sc =
      Handle(StepGeom_SurfaceCurve)::DownCast(C);
    Handle(StepGeom_Curve) C1 = Sc->Curve3d();
      MakeFromCurve3D (C1,EC,Vend,Precision(), E,V1,V2 , aTool);
  }
  else {
    // --- The Edge Geometry is a Single 3d Curve ---
    MakeFromCurve3D (C,EC,Vend,Precision(), E,V1,V2 , aTool);
  }
  // Force set flags SameRange and SameParameter to Standard_False
  if (done) {
//:S4136    B.SameRange(E, Standard_False);
//:S4136    B.SameParameter(E, Standard_False);
    aTool.Bind(EC,E);

    // Bind Edge in NM tool (ssv; 15.11.2010)
    if ( NMTool.IsActive() ) {
      NMTool.Bind(EC, E);
      if ( NMTool.IsIDEASCase() && !anECName.IsNull() && !anECName->IsEmpty() )
        NMTool.Bind(anECName->String(), E);
    }

    myResult = E;
    myError = StepToTopoDS_TranslateEdgeDone;
  }
}


// ============================================================================
// Method  : MakeFromCurve3D
// Purpose : case of a Curve 3D (alone or in SurfaceCurve)
// ============================================================================

// auxiliary function
//:e6 abv 16 Apr 98: ProSTEP TR8, r0601_sy.stp, #14907
static void GetCartesianPoints ( const Handle(StepShape_EdgeCurve)& EC, 
				 gp_Pnt &P1, gp_Pnt &P2)
{
  for ( Standard_Integer i=1; i<=2; i++ ) {
    const Handle(StepShape_Vertex) V = ((i == 1) == EC->SameSense() ? EC->EdgeStart() : EC->EdgeEnd() );
    const Handle(StepShape_VertexPoint) VP = Handle(StepShape_VertexPoint)::DownCast(V);
    if ( VP.IsNull() ) continue;
    const Handle(StepGeom_CartesianPoint) P = Handle(StepGeom_CartesianPoint)::DownCast(VP->VertexGeometry());
    Handle(Geom_CartesianPoint) CP = StepToGeom::MakeCartesianPoint (P);
    ( i==1 ? P1 : P2 ) = CP->Pnt();
  }
}

// ============================================================================
// Method  : StepToTopoDS_TranslateEdge::MakeFromCurve3D()
// Purpose : 
// ============================================================================

void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
  (const Handle(StepGeom_Curve)& C3D, const Handle(StepShape_EdgeCurve)& EC,
   const Handle(StepShape_Vertex)&  Vend,
   const Standard_Real preci, TopoDS_Edge& E,
   TopoDS_Vertex& V1, TopoDS_Vertex& V2,
   StepToTopoDS_Tool&   aTool)
{
  Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
  Handle(Geom_Curve) C1 = MakeCurve(C3D,TP);
  if (C1.IsNull()) {
    TP->AddFail(C3D," Make Geom_Curve (3D) failed");
    myError = StepToTopoDS_TranslateEdgeOther;
    done = Standard_False;
    return;
  }
    // -- Statistics -- -> No Warning message
  aTool.AddContinuity (C1);
  BRep_Builder B;
  Standard_Real temp1,temp2, U1,U2;
  gp_Pnt pproj;
  gp_Pnt pv1 = BRep_Tool::Pnt(V1);
  gp_Pnt pv2 = BRep_Tool::Pnt(V2);

  //:e6 abv
  gp_Pnt pnt1 = pv1, pnt2 = pv2;
  if ( V1.IsSame ( V2 ) ) GetCartesianPoints ( EC, pnt1, pnt2 );
  ShapeAnalysis_Curve sac;
  temp1 = sac.Project (C1,pnt1,preci,pproj,U1,Standard_False);
  temp2 = sac.Project (C1,pnt2,preci,pproj,U2,Standard_False);

  if (!StepToTopoDS_GeometricTool::UpdateParam3d(C1, U1, U2, preci))
    TP->AddWarning(C3D,"Update of 3D-Parameters has failed");

  //:d5: instead of AdjustCurve above which is incorrect if U1 and U2 are not ends
  GeomAdaptor_Curve aCA(C1);
  gp_Pnt pU1 = aCA.Value ( U1 ), pU2 = aCA.Value ( U2 );
  temp1 = pU1.Distance ( pv1 );
  temp2 = pU2.Distance ( pv2 );
  if ( temp1 > preci || temp2 > preci ) {
    TP->AddWarning (C3D,"Poor result from projection vertex / curve 3d");
  }
  B.UpdateVertex ( V1, 1.000001*temp1 ); //:h6 abv 14 Jul 98: PRO8845 #2746: *=1.0001
  B.UpdateVertex ( V2, 1.000001*temp2 ); //:h6
  
  BRepLib_MakeEdge ME(C1, V1, V2, U1, U2);
  if (ME.IsDone()) {
    E = ME.Edge();
    B.Range ( E, U1, U2 ); // abv 14 Mar 00: trj3_pm1-ug.stp #91739, edge 2
  }
  else {
    if (ME.Error() == BRepLib_DifferentPointsOnClosedCurve) {
      // The Edge could be closed and trimmed by 2 Different vertices
      if (C1->IsClosed()) {
	// Attention : topology updating
	aTool.Bind (Vend,V1);
	TopoDS_Shape aLocalShape = V1.Reversed();
	V2 = TopoDS::Vertex(aLocalShape);
	ME.Init(C1, V1, V2, U1, U2);
	if (ME.IsDone()) {
	  TP->AddWarning(EC, "Wrong topology corrected : Closed Edge with TWO different Vertices");
	  E = ME.Edge();
	}
	else {
	  DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
	  E = MakeEdge (C1,V1,V2,U1,U2);
	  myError = StepToTopoDS_TranslateEdgeDone;
	  done = Standard_True;
	  //		return;	  	      
        }
      }
      else {
	// Then, this is should be coded as degenerated
	// To be performed later !!!
	myError = StepToTopoDS_TranslateEdgeDone;
	//  Bon, on la fait cette petite edge, mais faudra repasser
	//  pour l enlever ET FUSIONNER LES VERTEX, pour tout le shell !
	//  courbe trop petite pour etre mise -> fait planter
	done = Standard_True;
	if (!V1.IsSame(V2)) {
	  TP->AddFail(EC, "This edge has null arc length");
	  gp_Pnt P1 = BRep_Tool::Pnt(V1);
	  gp_Pnt P2 = BRep_Tool::Pnt(V2);
	  gp_Vec avec (P1,P2);  gp_Dir adir (avec);  gp_Lin alin (P1,adir);
	  C1 = new Geom_Line (alin);
	  U1 = 0.;  U2 = P1.Distance(P2);
	  E = MakeEdge (C1,V1,V2,U1,U2);//,preci
	} 
	else {
	  TP->AddFail(EC,"NULL EDGE, SKIPPED");
	  myResult.Nullify();
	  return;	  
	}
      }
    }
    else {
      DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
      E = MakeEdge (C1,V1,V2,U1,U2);
      myError = StepToTopoDS_TranslateEdgeDone;
      done = Standard_True;
    }
  }
}


// ============================================================================
// Method  : MakePCurve
// Purpose : Computes an individual pcurve (i.e. curve 2d)
// ============================================================================
Handle(Geom2d_Curve)  StepToTopoDS_TranslateEdge::MakePCurve
  (const Handle(StepGeom_Pcurve)& PCU, const Handle(Geom_Surface)& ConvSurf) const
{
  Handle(Geom2d_Curve) C2d;
  const Handle(StepRepr_DefinitionalRepresentation) DRI = PCU->ReferenceToCurve();
  if( DRI.IsNull()) return C2d;
  const Handle(StepGeom_Curve) StepCurve = Handle(StepGeom_Curve)::DownCast(DRI->ItemsValue(1));
  try
  {
    C2d = StepToGeom::MakeCurve2d (StepCurve);
    if (! C2d.IsNull()) {
    // -- if the surface is a RectangularTrimmedSurface, 
    // -- send the BasisSurface.
     C2d = UnitsMethods::DegreeToRadian(C2d, ConvSurf);
    }
    
  }
  catch(Standard_Failure const&)
  {
    return C2d;
  }
  return C2d;
}


// ============================================================================
// Method  : Value
// Purpose : Returns the mapped edge
// ============================================================================

const TopoDS_Shape& StepToTopoDS_TranslateEdge::Value() const 
{
  StdFail_NotDone_Raise_if (!done, "StepToTopoDS_TranslateEdge::Value() - no result");
  return myResult;
}

// ============================================================================
// Method  : Error
// Purpose : Returns the error code
// ============================================================================

StepToTopoDS_TranslateEdgeError StepToTopoDS_TranslateEdge::Error() const
{
  return myError;
}
Commit	Line	Data
b311480e	1	// Created on: 1995-01-03
	2	// Created by: Frederic MAUPAS
	3	// Copyright (c) 1995-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.
b311480e	16
7fd59977	17	//:o0 abv 16.02.99: POLYLINE allowed as 3d curve of edge
	18	//gka,abv 05.04.99: S4136: improving tolerance management, eliminate BRepAPI::Precision()
	19
7fd59977	20	#include <BRep_Builder.hxx>
	21	#include <BRep_Tool.hxx>
	22	#include <BRepLib.hxx>
	23	#include <BRepLib_MakeEdge.hxx>
42cf5bc1	24	#include <GCPnts_AbscissaPoint.hxx>
	25	#include <Geom2d_Curve.hxx>
	26	#include <Geom_CartesianPoint.hxx>
7fd59977	27	#include <Geom_Curve.hxx>
7fd59977	28	#include <Geom_Line.hxx>
42cf5bc1	29	#include <Geom_Surface.hxx>
	30	#include <GeomAbs_Shape.hxx>
	31	#include <GeomAdaptor_Curve.hxx>
7fd59977	32	#include <gp_Dir.hxx>
7fd59977	33	#include <gp_Lin.hxx>
42cf5bc1	34	#include <gp_Vec.hxx>
42cf5bc1	35	#include <Precision.hxx>
7fd59977	36	#include <ShapeAnalysis_Curve.hxx>
7fd59977	37	#include <ShapeConstruct_Curve.hxx>
42cf5bc1	38	#include <StdFail_NotDone.hxx>
42cf5bc1	39	#include <StepGeom_CartesianPoint.hxx>
7fd59977	40	#include <StepGeom_Curve.hxx>
7fd59977	41	#include <StepGeom_Pcurve.hxx>
42cf5bc1	42	#include <StepGeom_Polyline.hxx>
7fd59977	43	#include <StepGeom_SurfaceCurve.hxx>
7fd59977	44	#include <StepRepr_DefinitionalRepresentation.hxx>
42cf5bc1	45	#include <StepShape_Edge.hxx>
	46	#include <StepShape_EdgeCurve.hxx>
	47	#include <StepShape_OrientedEdge.hxx>
	48	#include <StepShape_Vertex.hxx>
7fd59977	49	#include <StepShape_VertexPoint.hxx>
caaeed1b	50	#include <StepToGeom.hxx>
42cf5bc1	51	#include <StepToTopoDS.hxx>
	52	#include <StepToTopoDS_GeometricTool.hxx>
	53	#include <StepToTopoDS_NMTool.hxx>
	54	#include <StepToTopoDS_Tool.hxx>
	55	#include <StepToTopoDS_TranslateEdge.hxx>
	56	#include <StepToTopoDS_TranslateVertex.hxx>
7fd59977	57	#include <TCollection_HAsciiString.hxx>
42cf5bc1	58	#include <TopoDS.hxx>
	59	#include <TopoDS_Edge.hxx>
	60	#include <TopoDS_Shape.hxx>
	61	#include <TopoDS_Vertex.hxx>
	62	#include <Transfer_TransientProcess.hxx>
	63	#include <UnitsMethods.hxx>
82314bdf	64	#include <Standard_Failure.hxx>
7fd59977	65
42cf5bc1	66	//#include <StepGeom_Polyline.hxx>
	67	//#include <TransferBRep.hxx>
	68	//:d8
	69	// Used in I-DEAS-like STP processing (ssv; 15.11.2010)
7fd59977	70	//#define DEBUG
7fd59977	71	// ============================================================================
	72	// Method : DecodeMakeEdgeError
	73	// Purpose :
	74	// ============================================================================
7fd59977	75	static void DecodeMakeEdgeError(const BRepLib_MakeEdge& ME,
	76	const Handle(Standard_Transient)& orig,
	77	const Handle(Geom_Curve)& myCurve,
	78	const TopoDS_Vertex& V1,
	79	const TopoDS_Vertex& V2,
0797d9d3	80	const Standard_Real& U1,
0797d9d3	81	const Standard_Real& U2,
7fd59977	82	StepToTopoDS_Tool& aTool,
	83	const Handle(StepShape_TopologicalRepresentationItem)& /tobind/)
	84	{
0797d9d3	85	(void)U1, (void)U2; // avoid compiler warning
0797d9d3	86
7fd59977	87	Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
63c71e2f	88
0797d9d3	89	#ifdef OCCT_DEBUG
7fd59977	90	cout << "------------------------------------" << endl;
	91	cout << "MakeEdge Error : " << ME.Error()<<" - ";
	92	#endif
	93	switch(ME.Error())
	94	{
	95	case (BRepLib_EdgeDone): return;
	96	case (BRepLib_PointProjectionFailed):
	97	TP->AddFail(orig," Point Projection failed");
	98	break;
	99	case (BRepLib_ParameterOutOfRange):
	100	TP->AddFail(orig," Parameter Out Of Range");
	101	break;
	102	case (BRepLib_DifferentPointsOnClosedCurve):
	103	TP->AddFail(orig," Different Points on Closed Curve");
	104	break;
	105	case (BRepLib_PointWithInfiniteParameter):
	106	TP->AddFail(orig," Point with infinite Parameter");
	107	break;
	108	case (BRepLib_DifferentsPointAndParameter):
	109	if (!ShapeConstruct_Curve().AdjustCurve
	110	(myCurve,BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2),Standard_True,Standard_True))
	111	TP->AddFail(orig," Different Points and Parameters");
	112	else TP->AddWarning(orig,"Different Points and Parameters, adjusted");
	113	break;
	114	case (BRepLib_LineThroughIdenticPoints):
	115	TP->AddFail(orig," Line through identic Points");
	116	break;
	117	}
0797d9d3	118	#ifdef OCCT_DEBUG
7fd59977	119	cout << "Original Type : " << orig->DynamicType() << endl;
	120	cout << "3D Curve Type : " << myCurve->DynamicType() << endl;
	121	cout << "First Parameter : " << U1 << endl;
	122	gp_Pnt p1 = BRep_Tool::Pnt(V1);
	123	// cout << "First Point : ";
	124	cout << "First Vertex : "<<p1.X()<<" "<<p1.Y()<<" "<<p1.Z()<<" ";
	125	cout << "Distance Point - Vertex : ";
	126	Standard_Real d1 = p1.Distance(myCurve->Value(U1));
	127	cout << d1 << endl;
	128	cout << "Last Parameter : " << U2 << endl;
	129	gp_Pnt p2 = BRep_Tool::Pnt(V2);
	130	// cout << "Last Point : ";
	131	cout << "Last Vertex : "<<p2.X()<<" "<<p2.Y()<<" "<<p2.Z()<<" ";
	132	cout << "Distance Point - Vertex : ";
	133	Standard_Real d2 = BRep_Tool::Pnt(V2).Distance(myCurve->Value(U2));
	134	cout << d2 << endl;
	135	#endif
	136	}
	137
	138	// ============================================================================
	139	// Method : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge
	140	// Purpose : Empty Constructor
	141	// ============================================================================
	142
	143	static Handle(Geom_Curve) MakeCurve
	144	(const Handle(StepGeom_Curve)& C1, const Handle(Transfer_TransientProcess) TP)
	145	{
	146	Handle(Geom_Curve) C2 = Handle(Geom_Curve)::DownCast (TP->FindTransient(C1));
	147	if (!C2.IsNull()) return C2;
caaeed1b	148	C2 = StepToGeom::MakeCurve (C1);
caaeed1b	149	if (! C2.IsNull())
7fd59977	150	TP->BindTransient (C1,C2);
	151	return C2;
	152	}
	153
	154	static TopoDS_Edge MakeEdge
	155	(const Handle(Geom_Curve)& C3D,
	156	const TopoDS_Vertex& V1, const TopoDS_Vertex& V2,
63c71e2f	157	const Standard_Real U1, const Standard_Real U2)
7fd59977	158	{
7fd59977	159	BRep_Builder B;
7fd59977	160	TopoDS_Edge E;
63c71e2f	161	B.MakeEdge (E,C3D,Precision::Confusion());
7fd59977	162	B.Add (E,V1); B.Add (E,V2);
63c71e2f	163	B.UpdateVertex(V1, U1, E, 0.);
63c71e2f	164	B.UpdateVertex(V2, U2, E, 0.);
7fd59977	165	return E;
	166	}
	167
63c71e2f	168	// ============================================================================
	169	// Method : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
	170	// Purpose :
	171	// ============================================================================
	172
7fd59977	173	StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
	174	{
	175	done = Standard_False;
	176	}
	177
	178	// ============================================================================
	179	// Method : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
	180	// Purpose : Constructor with an Edge and a Tool
	181	// ============================================================================
	182
	183	StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge(const Handle(StepShape_Edge)& E,
	184	StepToTopoDS_Tool& T,
	185	StepToTopoDS_NMTool& NMTool)
	186	{
	187	Init(E, T, NMTool);
	188	}
	189
	190	// ============================================================================
	191	// Method : Init
	192	// Purpose : Init with an Edge and a Tool.
	193	// This method builds an Edge With 2 Vertices and 2 Parameters.
	194	// The Edge is always build like FORWARD (BRepLib_MakeEdge)
	195	// ============================================================================
	196
	197	void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge,
	198	StepToTopoDS_Tool& aTool,
	199	StepToTopoDS_NMTool& NMTool)
	200	{
	201	Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
	202
	203	Handle(StepShape_OrientedEdge) OE =
	204	Handle(StepShape_OrientedEdge)::DownCast(aEdge);
	205	Handle(StepShape_Edge) wEdge = aEdge;
	206	if ( ! OE.IsNull() ) wEdge = OE->EdgeElement();
	207	Handle(StepShape_EdgeCurve) EC = Handle(StepShape_EdgeCurve)::DownCast(wEdge);
	208
	209	if (aTool.IsBound(EC)) {
	210	myResult = aTool.Find(EC);
	211	if (BRep_Tool::Degenerated(TopoDS::Edge(myResult))) {
	212	TP->AddWarning(EC,"Degenerated Edge in several faces : transferred for each face");
	213	}
	214	else {
	215	myError = StepToTopoDS_TranslateEdgeDone;
	216	done = Standard_True;
7fd59977	217	//:S4136 B.SameRange(TopoDS::Edge(myResult), Standard_False); //:a5 abv 11 Feb 98
	218	//:S4136 B.SameParameter(TopoDS::Edge(myResult), Standard_False);//:a5
	219	return;
	220	}
	221	}
	222
	223	// [BEGIN] Proceed with non-manifold cases (ssv; 12.11.2010)
	224	if ( NMTool.IsActive() && NMTool.IsBound(EC) ) {
	225	TopoDS_Shape existingShape = NMTool.Find(EC);
	226	// Reverse shape's orientation if needed
	227	if ( !OE->Orientation() )
	228	existingShape.Reverse();
	229	myResult = existingShape;
	230	myError = StepToTopoDS_TranslateEdgeDone;
	231	done = Standard_True;
	232	return;
	233	}
	234	// [END] Proceed with non-manifold cases (ssv; 12.11.2010)
	235
	236	// [BEGIN] Proceed with I-DEAS-like STP (ssv; 15.11.2010)
	237	const Handle(TCollection_HAsciiString) anECName = EC->Name();
	238	if ( NMTool.IsIDEASCase() && !anECName.IsNull() && !anECName->IsEmpty() &&
	239	NMTool.IsBound(anECName->String()) ) {
	240	TopoDS_Shape existingShape = NMTool.Find(anECName->String());
	241	// Reverse shape's orientation if needed
	242	if ( !OE->Orientation() )
	243	existingShape.Reverse();
	244	// Register Edge for final processing (I-DEAS case)
	245	NMTool.RegisterNMEdge(existingShape);
	246	myResult = existingShape;
	247	myError = StepToTopoDS_TranslateEdgeDone;
	248	done = Standard_True;
	249	return;
	250	}
	251	// [END] Proceed with I-DEAS-like STP (ssv; 15.11.2010)
	252
	253	BRep_Builder B;
	254
7fd59977	255	Handle(StepGeom_Curve) C = EC->EdgeGeometry();
545ef510	256	if( C.IsNull())
	257	{
	258	TP->AddFail(EC," Geom Curve in EdgeCurve is equal to 0");
	259	myError = StepToTopoDS_TranslateEdgeOther;
	260	done = Standard_False;
	261	return;
	262	}
7fd59977	263	TopoDS_Edge E;
	264	Handle(StepShape_Vertex) Vstart, Vend;
	265
	266	// -----------------------------------------------------------
	267	// Extract the start and end Vertices corresponding to FORWARD
	268	// (following the geometrical sense)
	269	// -----------------------------------------------------------
	270
63c71e2f	271	Standard_Boolean EdgeCurveSameSense = EC->SameSense();
7fd59977	272
	273	if (EdgeCurveSameSense) {
	274	Vstart = EC->EdgeStart();
	275	Vend = EC->EdgeEnd();
	276	}
	277	else {
	278	Vend = EC->EdgeStart();
	279	Vstart = EC->EdgeEnd();
	280	}
	281
	282	TopoDS_Vertex V1, V2;
	283
	284	StepToTopoDS_TranslateVertex myTranVertex1(Vstart, aTool, NMTool);
	285	StepToTopoDS_TranslateVertex myTranVertex2(Vend, aTool, NMTool);
	286
	287	if (myTranVertex1.IsDone()) {
	288	V1 = TopoDS::Vertex(myTranVertex1.Value());
	289	V1.Orientation(TopAbs_FORWARD);
	290	}
	291	if (Vend == Vstart) {
	292	V2 = V1;
	293	V2.Orientation(TopAbs_REVERSED);
	294	}
	295	else if (myTranVertex2.IsDone()) {
	296	V2 = TopoDS::Vertex(myTranVertex2.Value());
	297	V2.Orientation(TopAbs_REVERSED);
	298	}
	299	done = Standard_True;
	300
	301	// ----------------------------------------------------------
	302	// --- The EdgeCurve Geometry is of StepGeom_Curve Type
	303	// --- It can be : * a Pcurve : no 3D curve is constructed
	304	// --- * a Surface Curve, Intersection Curve
	305	// --- or a Seam Curve
	306	// --- * a 3D Curve
	307	// ----------------------------------------------------------
	308
	309	if ( C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
	310	B.MakeEdge(E);
	311	//:S4136 B.UpdateEdge (E,preci);
63c71e2f	312	B.Add(E, V1);
7fd59977	313	B.Add(E, V2);
	314	}
	315	else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)) ) {
63c71e2f	316	// For SeamCurve and IntersectionCurve types
7fd59977	317	// --- The Edge Geometry is a Surface Curve ---
	318	// --- (3d + 2 Pcurve Or Surface) ---
	319	Handle(StepGeom_SurfaceCurve) Sc =
	320	Handle(StepGeom_SurfaceCurve)::DownCast(C);
	321	Handle(StepGeom_Curve) C1 = Sc->Curve3d();
7fd59977	322	MakeFromCurve3D (C1,EC,Vend,Precision(), E,V1,V2 , aTool);
7fd59977	323	}
7fd59977	324	else {
	325	// --- The Edge Geometry is a Single 3d Curve ---
	326	MakeFromCurve3D (C,EC,Vend,Precision(), E,V1,V2 , aTool);
	327	}
63c71e2f	328	// Force set flags SameRange and SameParameter to Standard_False
7fd59977	329	if (done) {
	330	//:S4136 B.SameRange(E, Standard_False);
	331	//:S4136 B.SameParameter(E, Standard_False);
	332	aTool.Bind(EC,E);
	333
	334	// Bind Edge in NM tool (ssv; 15.11.2010)
	335	if ( NMTool.IsActive() ) {
	336	NMTool.Bind(EC, E);
	337	if ( NMTool.IsIDEASCase() && !anECName.IsNull() && !anECName->IsEmpty() )
	338	NMTool.Bind(anECName->String(), E);
	339	}
	340
	341	myResult = E;
	342	myError = StepToTopoDS_TranslateEdgeDone;
	343	}
	344	}
	345
	346
	347	// ============================================================================
	348	// Method : MakeFromCurve3D
	349	// Purpose : case of a Curve 3D (alone or in SurfaceCurve)
	350	// ============================================================================
	351
	352	// auxiliary function
	353	//:e6 abv 16 Apr 98: ProSTEP TR8, r0601_sy.stp, #14907
	354	static void GetCartesianPoints ( const Handle(StepShape_EdgeCurve)& EC,
	355	gp_Pnt &P1, gp_Pnt &P2)
	356	{
	357	for ( Standard_Integer i=1; i<=2; i++ ) {
dde68833	358	const Handle(StepShape_Vertex) V = ((i == 1) == EC->SameSense() ? EC->EdgeStart() : EC->EdgeEnd() );
7fd59977	359	const Handle(StepShape_VertexPoint) VP = Handle(StepShape_VertexPoint)::DownCast(V);
	360	if ( VP.IsNull() ) continue;
	361	const Handle(StepGeom_CartesianPoint) P = Handle(StepGeom_CartesianPoint)::DownCast(VP->VertexGeometry());
caaeed1b	362	Handle(Geom_CartesianPoint) CP = StepToGeom::MakeCartesianPoint (P);
caaeed1b	363	( i==1 ? P1 : P2 ) = CP->Pnt();
7fd59977	364	}
	365	}
	366
63c71e2f	367	// ============================================================================
	368	// Method : StepToTopoDS_TranslateEdge::MakeFromCurve3D()
	369	// Purpose :
	370	// ============================================================================
	371
7fd59977	372	void StepToTopoDS_TranslateEdge::MakeFromCurve3D
	373	(const Handle(StepGeom_Curve)& C3D, const Handle(StepShape_EdgeCurve)& EC,
	374	const Handle(StepShape_Vertex)& Vend,
	375	const Standard_Real preci, TopoDS_Edge& E,
	376	TopoDS_Vertex& V1, TopoDS_Vertex& V2,
	377	StepToTopoDS_Tool& aTool)
	378	{
	379	Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
	380	Handle(Geom_Curve) C1 = MakeCurve(C3D,TP);
	381	if (C1.IsNull()) {
	382	TP->AddFail(C3D," Make Geom_Curve (3D) failed");
	383	myError = StepToTopoDS_TranslateEdgeOther;
	384	done = Standard_False;
	385	return;
	386	}
	387	// -- Statistics -- -> No Warning message
	388	aTool.AddContinuity (C1);
	389	BRep_Builder B;
	390	Standard_Real temp1,temp2, U1,U2;
	391	gp_Pnt pproj;
	392	gp_Pnt pv1 = BRep_Tool::Pnt(V1);
	393	gp_Pnt pv2 = BRep_Tool::Pnt(V2);
	394
	395	//:e6 abv
	396	gp_Pnt pnt1 = pv1, pnt2 = pv2;
	397	if ( V1.IsSame ( V2 ) ) GetCartesianPoints ( EC, pnt1, pnt2 );
	398	ShapeAnalysis_Curve sac;
	399	temp1 = sac.Project (C1,pnt1,preci,pproj,U1,Standard_False);
	400	temp2 = sac.Project (C1,pnt2,preci,pproj,U2,Standard_False);
	401
	402	if (!StepToTopoDS_GeometricTool::UpdateParam3d(C1, U1, U2, preci))
	403	TP->AddWarning(C3D,"Update of 3D-Parameters has failed");
	404
	405	//:d5: instead of AdjustCurve above which is incorrect if U1 and U2 are not ends
94f71cad	406	GeomAdaptor_Curve aCA(C1);
94f71cad	407	gp_Pnt pU1 = aCA.Value ( U1 ), pU2 = aCA.Value ( U2 );
7fd59977	408	temp1 = pU1.Distance ( pv1 );
	409	temp2 = pU2.Distance ( pv2 );
	410	if ( temp1 > preci \|\| temp2 > preci ) {
	411	TP->AddWarning (C3D,"Poor result from projection vertex / curve 3d");
	412	}
	413	B.UpdateVertex ( V1, 1.000001temp1 ); //:h6 abv 14 Jul 98: PRO8845 #2746: =1.0001
	414	B.UpdateVertex ( V2, 1.000001*temp2 ); //:h6
	415
	416	BRepLib_MakeEdge ME(C1, V1, V2, U1, U2);
	417	if (ME.IsDone()) {
	418	E = ME.Edge();
	419	B.Range ( E, U1, U2 ); // abv 14 Mar 00: trj3_pm1-ug.stp #91739, edge 2
	420	}
	421	else {
	422	if (ME.Error() == BRepLib_DifferentPointsOnClosedCurve) {
63c71e2f	423	// The Edge could be closed and trimmed by 2 Different vertices
7fd59977	424	if (C1->IsClosed()) {
63c71e2f	425	// Attention : topology updating
7fd59977	426	aTool.Bind (Vend,V1);
	427	TopoDS_Shape aLocalShape = V1.Reversed();
	428	V2 = TopoDS::Vertex(aLocalShape);
	429	ME.Init(C1, V1, V2, U1, U2);
	430	if (ME.IsDone()) {
	431	TP->AddWarning(EC, "Wrong topology corrected : Closed Edge with TWO different Vertices");
	432	E = ME.Edge();
	433	}
	434	else {
	435	DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
63c71e2f	436	E = MakeEdge (C1,V1,V2,U1,U2);
63c71e2f	437	myError = StepToTopoDS_TranslateEdgeDone;
7fd59977	438	done = Standard_True;
	439	// return;
	440	}
	441	}
	442	else {
	443	// Then, this is should be coded as degenerated
	444	// To be performed later !!!
63c71e2f	445	myError = StepToTopoDS_TranslateEdgeDone;
7fd59977	446	// Bon, on la fait cette petite edge, mais faudra repasser
	447	// pour l enlever ET FUSIONNER LES VERTEX, pour tout le shell !
	448	// courbe trop petite pour etre mise -> fait planter
	449	done = Standard_True;
	450	if (!V1.IsSame(V2)) {
	451	TP->AddFail(EC, "This edge has null arc length");
	452	gp_Pnt P1 = BRep_Tool::Pnt(V1);
	453	gp_Pnt P2 = BRep_Tool::Pnt(V2);
	454	gp_Vec avec (P1,P2); gp_Dir adir (avec); gp_Lin alin (P1,adir);
	455	C1 = new Geom_Line (alin);
	456	U1 = 0.; U2 = P1.Distance(P2);
	457	E = MakeEdge (C1,V1,V2,U1,U2);//,preci
	458	}
	459	else {
	460	TP->AddFail(EC,"NULL EDGE, SKIPPED");
	461	myResult.Nullify();
	462	return;
	463	}
	464	}
	465	}
	466	else {
	467	DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
63c71e2f	468	E = MakeEdge (C1,V1,V2,U1,U2);
63c71e2f	469	myError = StepToTopoDS_TranslateEdgeDone;
7fd59977	470	done = Standard_True;
	471	}
	472	}
	473	}
	474
	475
	476	// ============================================================================
	477	// Method : MakePCurve
	478	// Purpose : Computes an individual pcurve (i.e. curve 2d)
	479	// ============================================================================
	480	Handle(Geom2d_Curve) StepToTopoDS_TranslateEdge::MakePCurve
	481	(const Handle(StepGeom_Pcurve)& PCU, const Handle(Geom_Surface)& ConvSurf) const
	482	{
	483	Handle(Geom2d_Curve) C2d;
	484	const Handle(StepRepr_DefinitionalRepresentation) DRI = PCU->ReferenceToCurve();
	485	if( DRI.IsNull()) return C2d;
	486	const Handle(StepGeom_Curve) StepCurve = Handle(StepGeom_Curve)::DownCast(DRI->ItemsValue(1));
82314bdf	487	try
	488	{
	489	C2d = StepToGeom::MakeCurve2d (StepCurve);
	490	if (! C2d.IsNull()) {
7fd59977	491	// -- if the surface is a RectangularTrimmedSurface,
7fd59977	492	// -- send the BasisSurface.
82314bdf	493	C2d = UnitsMethods::DegreeToRadian(C2d, ConvSurf);
	494	}
	495
	496	}
a738b534	497	catch(Standard_Failure const&)
82314bdf	498	{
82314bdf	499	return C2d;
7fd59977	500	}
	501	return C2d;
	502	}
	503
	504
	505	// ============================================================================
	506	// Method : Value
	507	// Purpose : Returns the mapped edge
	508	// ============================================================================
	509
	510	const TopoDS_Shape& StepToTopoDS_TranslateEdge::Value() const
	511	{
2d2b3d53	512	StdFail_NotDone_Raise_if (!done, "StepToTopoDS_TranslateEdge::Value() - no result");
7fd59977	513	return myResult;
	514	}
	515
	516	// ============================================================================
	517	// Method : Error
	518	// Purpose : Returns the error code
	519	// ============================================================================
	520
	521	StepToTopoDS_TranslateEdgeError StepToTopoDS_TranslateEdge::Error() const
	522	{
	523	return myError;
	524	}