[occt.git] / src / LocOpe / LocOpe.cxx

// Created on: 1996-04-02
// Created by: Jacques GOUSSARD
// 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 <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dInt_GInter.hxx>
#include <Geom_Curve.hxx>
#include <gp_Pnt2d.hxx>
#include <LocOpe.hxx>
#include <Precision.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_MapOfShape.hxx>

#define NECHANT 10


//=======================================================================
//function : Closed
//purpose  : 
//=======================================================================

Standard_Boolean LocOpe::Closed(const TopoDS_Wire& W,
				const TopoDS_Face& F)
{
  TopoDS_Vertex Vf,Vl;
  TopExp::Vertices(W,Vf,Vl);
  if (!Vf.IsSame(Vl)) {
    return Standard_False;
  }

  // On recherche l`edge contenant Vf FORWARD

  TopExp_Explorer exp,exp2;
  for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
       exp.More();exp.Next()) {
    for (exp2.Init(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next()) {
      if (exp2.Current().IsSame(Vf) && 
	  exp2.Current().Orientation() == TopAbs_FORWARD) {
	break;
      }
    }
    if (exp2.More()) {
      break;
    }
  }
  TopoDS_Edge Ef = TopoDS::Edge(exp.Current());
  
  // On recherche l`edge contenant Vl REVERSED

  for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
       exp.More();exp.Next()) {
    for (exp2.Init(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next()) {
      if (exp2.Current().IsSame(Vl) && 
	  exp2.Current().Orientation() == TopAbs_REVERSED) {
	break;
      }
    }
    if (exp2.More()) {
      break;
    }
  }
  TopoDS_Edge El = TopoDS::Edge(exp.Current());
  
  Standard_Real f,l;
  gp_Pnt2d pf,pl;
  Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(Ef,F,f,l);
  if (Ef.Orientation() == TopAbs_FORWARD) {
    pf = C2d->Value(f);
  }
  else {
    pf = C2d->Value(l);
  }
  C2d = BRep_Tool::CurveOnSurface(El,F,f,l);
  if (El.Orientation() == TopAbs_FORWARD) {
    pl = C2d->Value(l);
  }
  else {
    pl = C2d->Value(f);
  }

  if (pf.Distance(pl) <= Precision::PConfusion(Precision::Confusion())) {
    return Standard_True;
  }
  return Standard_False;
}


//=======================================================================
//function : Closed
//purpose  : 
//=======================================================================

Standard_Boolean LocOpe::Closed(const TopoDS_Edge& E,
				const TopoDS_Face& F)
{
  BRep_Builder B;
  TopoDS_Wire W;
  B.MakeWire(W);
  B.Add(W,E.Oriented(TopAbs_FORWARD));
  return LocOpe::Closed(W,F);
}


//=======================================================================
//function : Closed
//purpose  : 
//=======================================================================

Standard_Boolean LocOpe::TgtFaces(const TopoDS_Edge& E,
				  const TopoDS_Face& F1,
				  const TopoDS_Face& F2)
{
  BRepAdaptor_Surface bs(F1, Standard_False);
  Standard_Real u;
  Standard_Real ta = 0.0001;

  TopoDS_Edge e = E;

  Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface(F1);
  Handle(BRepAdaptor_HSurface) HS2 = new BRepAdaptor_HSurface(F2);
  e.Orientation(TopAbs_FORWARD);
  Handle(BRepAdaptor_HCurve2d) HC2d = new BRepAdaptor_HCurve2d();
  Handle(BRepAdaptor_HCurve2d) HC2d2 = new BRepAdaptor_HCurve2d();
  HC2d->ChangeCurve2d().Initialize(e,F1);
  HC2d2->ChangeCurve2d().Initialize(e,F2);
  

//  Adaptor3d_CurveOnSurface C1(HC2d,HS1);

  Standard_Boolean rev1 = (F1.Orientation() == TopAbs_REVERSED);
  Standard_Boolean rev2 = (F2.Orientation() == TopAbs_REVERSED);
  Standard_Real f,l,eps,angmin = M_PI,angmax = -M_PI,ang;
  BRep_Tool::Range(e,f,l);

  eps = (l - f)/100.;
  f += eps; // pour eviter de faire des calculs sur les 
  l -= eps; // pointes des carreaux pointus.
  gp_Pnt2d p;
  gp_Pnt pp1;
  gp_Vec du,dv;
  gp_Vec d1,d2;

  Standard_Real uu, vv;

  Standard_Integer i;
  for(i = 0; i <= 20; i++){
    u = f + (l-f)*i/20;
    HC2d->D0(u,p);
    HS1->D1(p.X(),p.Y(),pp1,du,dv);
    d1 = (du.Crossed(dv)).Normalized();
    if(rev1) d1.Reverse();
    HC2d2->D0(u,p);
    p.Coord(uu,vv);
    HS2->D1(uu,vv,pp1,du,dv);
    d2 = (du.Crossed(dv)).Normalized();
    if(rev2) d2.Reverse();
    ang = d1.Angle(d2);
    if(ang <= angmin) angmin = ang;
    if(ang >= angmax) angmax = ang;
  }
  return (angmax<=ta);
}


//=======================================================================
//function : SampleEdges
//purpose  : 
//=======================================================================

void LocOpe::SampleEdges(const TopoDS_Shape& theShape,
			 TColgp_SequenceOfPnt& theSeq)
{
  theSeq.Clear();
  TopTools_MapOfShape theMap;
  
  TopExp_Explorer exp(theShape,TopAbs_EDGE);
  TopLoc_Location Loc;
  Handle(Geom_Curve) C;
  Standard_Real f,l,prm;
  Standard_Integer i;

  // Computes points on edge, but does not take the extremities into account
  for (; exp.More(); exp.Next()) {
    const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
    if (!theMap.Add(edg)) {
      continue;
    }
    if (!BRep_Tool::Degenerated(edg)) {
      C = BRep_Tool::Curve(edg,Loc,f,l);
      C = Handle(Geom_Curve)::
	DownCast(C->Transformed(Loc.Transformation()));
      Standard_Real delta = (l - f)/NECHANT*0.123456;
      for (i=1; i<NECHANT; i++) {
	prm = delta + ((NECHANT-i)*f+i*l)/NECHANT;
	theSeq.Append(C->Value(prm));
      }
    }
  }

  // Adds every vertex
  for (exp.Init(theShape,TopAbs_VERTEX); exp.More(); exp.Next()) {
    if (theMap.Add(exp.Current())) {
      theSeq.Append(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current())));
    }
  }
}


/*
Standard_Boolean LocOpe::IsInside(const TopoDS_Face& F1,
				  const TopoDS_Face& F2)
{
  Standard_Boolean Result = Standard_True;

  TopExp_Explorer exp1, exp2;

  for(exp1.Init(F1, TopAbs_EDGE); exp1.More(); exp1.Next())  {
    TopoDS_Edge e1 = TopoDS::Edge(exp1.Current());
    BRepAdaptor_Curve2d C1(e1, F1); 
    for(exp2.Init(F2, TopAbs_EDGE); exp2.More(); exp2.Next())  {
      TopoDS_Edge e2 = TopoDS::Edge(exp2.Current());
      BRepAdaptor_Curve2d C2(e2, F2); 
      Geom2dInt_GInter C;
      C.Perform(C1, C2, Precision::Confusion(), Precision::Confusion());
      if(!C.IsEmpty()) Result = Standard_False;
      if(Result == Standard_False) {
	for(exp3.Init(e2, TopAbs_VERTEX); exp3.More(); exp3.Next())  {
	  
        }
      }
    }
    if(Result == Standard_False) break;
  }
  return Result;
}

*/
Commit	Line	Data
b311480e	1	// Created on: 1996-04-02
	2	// Created by: Jacques GOUSSARD
	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
7fd59977	17
7fd59977	18	#include <BRep_Builder.hxx>
42cf5bc1	19	#include <BRep_Tool.hxx>
7fd59977	20	#include <BRepAdaptor_Curve2d.hxx>
7fd59977	21	#include <BRepAdaptor_HCurve2d.hxx>
42cf5bc1	22	#include <BRepAdaptor_HSurface.hxx>
42cf5bc1	23	#include <Geom2d_Curve.hxx>
7fd59977	24	#include <Geom2dInt_GInter.hxx>
7fd59977	25	#include <Geom_Curve.hxx>
42cf5bc1	26	#include <gp_Pnt2d.hxx>
	27	#include <LocOpe.hxx>
	28	#include <Precision.hxx>
7fd59977	29	#include <TopExp.hxx>
42cf5bc1	30	#include <TopExp_Explorer.hxx>
7fd59977	31	#include <TopoDS.hxx>
42cf5bc1	32	#include <TopoDS_Edge.hxx>
	33	#include <TopoDS_Face.hxx>
	34	#include <TopoDS_Shape.hxx>
7fd59977	35	#include <TopoDS_Vertex.hxx>
42cf5bc1	36	#include <TopoDS_Wire.hxx>
42cf5bc1	37	#include <TopTools_MapOfShape.hxx>
7fd59977	38
	39	#define NECHANT 10
	40
	41
	42	//=======================================================================
	43	//function : Closed
	44	//purpose :
	45	//=======================================================================
	46
	47	Standard_Boolean LocOpe::Closed(const TopoDS_Wire& W,
	48	const TopoDS_Face& F)
	49	{
	50	TopoDS_Vertex Vf,Vl;
	51	TopExp::Vertices(W,Vf,Vl);
	52	if (!Vf.IsSame(Vl)) {
	53	return Standard_False;
	54	}
	55
	56	// On recherche l`edge contenant Vf FORWARD
	57
	58	TopExp_Explorer exp,exp2;
	59	for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
	60	exp.More();exp.Next()) {
	61	for (exp2.Init(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next()) {
	62	if (exp2.Current().IsSame(Vf) &&
	63	exp2.Current().Orientation() == TopAbs_FORWARD) {
	64	break;
	65	}
	66	}
	67	if (exp2.More()) {
	68	break;
	69	}
	70	}
	71	TopoDS_Edge Ef = TopoDS::Edge(exp.Current());
	72
	73	// On recherche l`edge contenant Vl REVERSED
	74
	75	for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
	76	exp.More();exp.Next()) {
	77	for (exp2.Init(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next()) {
	78	if (exp2.Current().IsSame(Vl) &&
	79	exp2.Current().Orientation() == TopAbs_REVERSED) {
	80	break;
	81	}
	82	}
	83	if (exp2.More()) {
	84	break;
	85	}
	86	}
	87	TopoDS_Edge El = TopoDS::Edge(exp.Current());
	88
	89	Standard_Real f,l;
	90	gp_Pnt2d pf,pl;
	91	Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(Ef,F,f,l);
	92	if (Ef.Orientation() == TopAbs_FORWARD) {
	93	pf = C2d->Value(f);
	94	}
	95	else {
	96	pf = C2d->Value(l);
	97	}
	98	C2d = BRep_Tool::CurveOnSurface(El,F,f,l);
	99	if (El.Orientation() == TopAbs_FORWARD) {
	100	pl = C2d->Value(l);
	101	}
102	else {
103	pl = C2d->Value(f);
104	}
105
106	if (pf.Distance(pl) <= Precision::PConfusion(Precision::Confusion())) {
107	return Standard_True;
108	}
109	return Standard_False;
110	}
111
112
113	//=======================================================================
114	//function : Closed
115	//purpose :
116	//=======================================================================
117
118	Standard_Boolean LocOpe::Closed(const TopoDS_Edge& E,
119	const TopoDS_Face& F)
120	{
121	BRep_Builder B;
122	TopoDS_Wire W;
123	B.MakeWire(W);
124	B.Add(W,E.Oriented(TopAbs_FORWARD));
125	return LocOpe::Closed(W,F);
126	}
127
128
129
130	//=======================================================================
131	//function : Closed
132	//purpose :
133	//=======================================================================
134
135	Standard_Boolean LocOpe::TgtFaces(const TopoDS_Edge& E,
136	const TopoDS_Face& F1,
137	const TopoDS_Face& F2)
138	{
139	BRepAdaptor_Surface bs(F1, Standard_False);
140	Standard_Real u;
141	Standard_Real ta = 0.0001;
142
143	TopoDS_Edge e = E;
144
145	Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface(F1);
146	Handle(BRepAdaptor_HSurface) HS2 = new BRepAdaptor_HSurface(F2);
147	e.Orientation(TopAbs_FORWARD);
148	Handle(BRepAdaptor_HCurve2d) HC2d = new BRepAdaptor_HCurve2d();
149	Handle(BRepAdaptor_HCurve2d) HC2d2 = new BRepAdaptor_HCurve2d();
150	HC2d->ChangeCurve2d().Initialize(e,F1);
151	HC2d2->ChangeCurve2d().Initialize(e,F2);
152
153
154	// Adaptor3d_CurveOnSurface C1(HC2d,HS1);
155
156	Standard_Boolean rev1 = (F1.Orientation() == TopAbs_REVERSED);
157	Standard_Boolean rev2 = (F2.Orientation() == TopAbs_REVERSED);
c6541a0c	158	Standard_Real f,l,eps,angmin = M_PI,angmax = -M_PI,ang;
7fd59977	159	BRep_Tool::Range(e,f,l);
	160
	161	eps = (l - f)/100.;
	162	f += eps; // pour eviter de faire des calculs sur les
	163	l -= eps; // pointes des carreaux pointus.
	164	gp_Pnt2d p;
	165	gp_Pnt pp1;
	166	gp_Vec du,dv;
	167	gp_Vec d1,d2;
	168
	169	Standard_Real uu, vv;
7fd59977	170
	171	Standard_Integer i;
	172	for(i = 0; i <= 20; i++){
	173	u = f + (l-f)*i/20;
	174	HC2d->D0(u,p);
	175	HS1->D1(p.X(),p.Y(),pp1,du,dv);
	176	d1 = (du.Crossed(dv)).Normalized();
	177	if(rev1) d1.Reverse();
	178	HC2d2->D0(u,p);
	179	p.Coord(uu,vv);
	180	HS2->D1(uu,vv,pp1,du,dv);
	181	d2 = (du.Crossed(dv)).Normalized();
	182	if(rev2) d2.Reverse();
	183	ang = d1.Angle(d2);
7fd59977	184	if(ang <= angmin) angmin = ang;
	185	if(ang >= angmax) angmax = ang;
	186	}
	187	return (angmax<=ta);
	188	}
	189
	190
	191	//=======================================================================
	192	//function : SampleEdges
	193	//purpose :
	194	//=======================================================================
	195
	196	void LocOpe::SampleEdges(const TopoDS_Shape& theShape,
	197	TColgp_SequenceOfPnt& theSeq)
	198	{
	199	theSeq.Clear();
	200	TopTools_MapOfShape theMap;
	201
	202	TopExp_Explorer exp(theShape,TopAbs_EDGE);
	203	TopLoc_Location Loc;
	204	Handle(Geom_Curve) C;
	205	Standard_Real f,l,prm;
	206	Standard_Integer i;
	207
	208	// Computes points on edge, but does not take the extremities into account
	209	for (; exp.More(); exp.Next()) {
	210	const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
	211	if (!theMap.Add(edg)) {
	212	continue;
	213	}
	214	if (!BRep_Tool::Degenerated(edg)) {
	215	C = BRep_Tool::Curve(edg,Loc,f,l);
	216	C = Handle(Geom_Curve)::
	217	DownCast(C->Transformed(Loc.Transformation()));
	218	Standard_Real delta = (l - f)/NECHANT*0.123456;
	219	for (i=1; i<NECHANT; i++) {
	220	prm = delta + ((NECHANT-i)f+il)/NECHANT;
	221	theSeq.Append(C->Value(prm));
	222	}
	223	}
	224	}
	225
	226	// Adds every vertex
	227	for (exp.Init(theShape,TopAbs_VERTEX); exp.More(); exp.Next()) {
	228	if (theMap.Add(exp.Current())) {
	229	theSeq.Append(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current())));
	230	}
	231	}
	232	}
	233
	234
	235
	236
	237
	238	/*
	239	Standard_Boolean LocOpe::IsInside(const TopoDS_Face& F1,
	240	const TopoDS_Face& F2)
	241	{
	242	Standard_Boolean Result = Standard_True;
	243
	244	TopExp_Explorer exp1, exp2;
	245
	246	for(exp1.Init(F1, TopAbs_EDGE); exp1.More(); exp1.Next()) {
	247	TopoDS_Edge e1 = TopoDS::Edge(exp1.Current());
248	BRepAdaptor_Curve2d C1(e1, F1);
249	for(exp2.Init(F2, TopAbs_EDGE); exp2.More(); exp2.Next()) {
250	TopoDS_Edge e2 = TopoDS::Edge(exp2.Current());
251	BRepAdaptor_Curve2d C2(e2, F2);
252	Geom2dInt_GInter C;
253	C.Perform(C1, C2, Precision::Confusion(), Precision::Confusion());
254	if(!C.IsEmpty()) Result = Standard_False;
255	if(Result == Standard_False) {
256	for(exp3.Init(e2, TopAbs_VERTEX); exp3.More(); exp3.Next()) {
257
258	}
259	}
260	}
261	if(Result == Standard_False) break;
262	}
263	return Result;
264	}
265
266	*/
267
268
269