[occt.git] / src / ApproxInt / ApproxInt_PrmPrmSvSurfaces.gxx

// File:	ApproxInt_PrmPrmSvSurfaces.gxx
// Created:	Wed Mar 17 12:42:28 1993
// Author:	Laurent BUCHARD
//		<lbr@topsn3>

#define TOLTANGENCY 0.0000000001


#include <TColStd_Array1OfReal.hxx>
#include <math_FunctionSetRoot.hxx>

#define Debug(expr)  cout<<" expr :"<<expr;
#define MySurf1 MyIntersectionOn2S.Function().AuxillarSurface1()
#define MySurf2 MyIntersectionOn2S.Function().AuxillarSurface2()


//--------------------------------------------------------------------------------
ApproxInt_PrmPrmSvSurfaces::ApproxInt_PrmPrmSvSurfaces( const ThePSurface& Surf1
						       ,const ThePSurface& Surf2):
       MyHasBeenComputed(Standard_False),
       MyHasBeenComputedbis(Standard_False),
       MyIntersectionOn2S(Surf1,Surf2,TOLTANGENCY)
{ 
}
//--------------------------------------------------------------------------------
Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Compute( Standard_Real& u1
						     ,Standard_Real& v1
						     ,Standard_Real& u2
						     ,Standard_Real& v2
						     ,gp_Pnt& P
						     ,gp_Vec& Tg
						     ,gp_Vec2d& Tguv1
						     ,gp_Vec2d& Tguv2) { 
  
  Standard_Real tu1=u1;
  Standard_Real tu2=u2;
  Standard_Real tv1=v1;
  Standard_Real tv2=v2;
  
  if(MyHasBeenComputed) { 
    if(  (MyParOnS1.X()==u1)&&(MyParOnS1.Y()==v1)
       &&(MyParOnS2.X()==u2)&&(MyParOnS2.Y()==v2)) {
      return(MyIsTangent);
    }
    else if(MyHasBeenComputedbis == Standard_False) { 
      MyTgbis         = MyTg;
      MyTguv1bis      = MyTguv1;
      MyTguv2bis      = MyTguv2;
      MyPntbis        = MyPnt;
      MyParOnS1bis    = MyParOnS1;
      MyParOnS2bis    = MyParOnS2;
      MyIsTangentbis  = MyIsTangent;
      MyHasBeenComputedbis = MyHasBeenComputed; 
    }
  }
  if(MyHasBeenComputedbis) { 
    if(  (MyParOnS1bis.X()==u1)&&(MyParOnS1bis.Y()==v1)
       &&(MyParOnS2bis.X()==u2)&&(MyParOnS2bis.Y()==v2)) {

      gp_Vec            TV(MyTg);
      gp_Vec2d          TV1(MyTguv1);
      gp_Vec2d          TV2(MyTguv2);
      gp_Pnt            TP(MyPnt);
      gp_Pnt2d          TP1(MyParOnS1);
      gp_Pnt2d          TP2(MyParOnS2);
      Standard_Boolean  TB=MyIsTangent;

      MyTg        = MyTgbis;
      MyTguv1     = MyTguv1bis;
      MyTguv2     = MyTguv2bis;
      MyPnt       = MyPntbis;
      MyParOnS1   = MyParOnS1bis;
      MyParOnS2   = MyParOnS2bis;
      MyIsTangent = MyIsTangentbis;

      MyTgbis         = TV;
      MyTguv1bis      = TV1;
      MyTguv2bis      = TV2;
      MyPntbis        = TP;
      MyParOnS1bis    = TP1;
      MyParOnS2bis    = TP2;
      MyIsTangentbis  = TB;

      return(MyIsTangent);
    }
  }


  MyIsTangent = Standard_True;

  static TColStd_Array1OfReal Param(1,4);
  Param(1) = u1; Param(2) = v1;
  Param(3) = u2; Param(4) = v2;
  math_FunctionSetRoot  Rsnld(MyIntersectionOn2S.Function());
  MyIntersectionOn2S.Perform(Param,Rsnld);
  if (!MyIntersectionOn2S.IsDone())  { 
    MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
    return(Standard_False);
  }
  if (MyIntersectionOn2S.IsEmpty()) {
    MyIsTangent=Standard_False;
    //cout<<"\n----- Parametree Parametree : IsEmpty ds Compute "<<endl;
    //Debug(u1); Debug(u2); Debug(v1); Debug(v2);   cout<<endl;
    MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
    return(Standard_False);
  }
  MyHasBeenComputed = Standard_True;
  MyPnt = P = MyIntersectionOn2S.Point().Value();
  
  MyIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
  MyParOnS1.SetCoord(tu1,tv1);
  MyParOnS2.SetCoord(tu2,tv2);
  
  if(MyIntersectionOn2S.IsTangent()) { 
    MyIsTangent=Standard_False;
    MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
    return(Standard_False); 
  }
  MyTg    = Tg    = MyIntersectionOn2S.Direction();
  MyTguv1 = Tguv1 = MyIntersectionOn2S.DirectionOnS1();
  MyTguv2 = Tguv2 = MyIntersectionOn2S.DirectionOnS2();

  //----------------------------------------------------------------------
  //-- Si ( Tg )    TU et TV sont normes 
  //-- 
  //-- On a    Tg   =  DeltaU  *  TU    +   DeltaV  *  TV
  //-- 
  //-- soit :  Tg.TU  =  DeltaU  TU.TU  +   DeltaV  TU.TV
  //--         Tg.TV  =  DeltaU  TV.TU  +   DeltaV  TV.TV 
  //-- 
  //-- Donc : 
  //--
  //--               Tg.TU TV.TV  - Tg.TV * TU.TV
  //--   DeltaU = -------------------------------
  //--               TU.TU TV.TV  - (TU.TV)**2
  //-- 
  //--               Tg.TV TU.TU  - Tg.TU * TU.TV
  //--   DeltaV = -------------------------------
  //--               TU.TU TV.TV  - (TU.TV)**2
  //--
  //--

  Tg.Normalize();    MyTg = Tg; 

  Standard_Real DeltaU,DeltaV;
  gp_Vec TU,TV;
  gp_Pnt Pbid;
  Standard_Real TUTV,TgTU,TgTV,TUTU,TVTV,DIS;
  //------------------------------------------------------------
  //-- Calcul de Tguv1
  //--
  ThePSurfaceTool::D1(MySurf1,u1,v1,Pbid,TU,TV);
  
  TUTU = TU.Dot(TU);
  TVTV = TV.Dot(TV);
  TUTV = TU.Dot(TV);
  TgTU = Tg.Dot(TU);
  TgTV = Tg.Dot(TV);
  DIS  = TUTU * TVTV - TUTV * TUTV;
  
  DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ; 
  DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;

  Tguv1.SetCoord(DeltaU,DeltaV);  MyTguv1 = Tguv1;

  //------------------------------------------------------------
  //-- Calcul de Tguv2
  //--  
  ThePSurfaceTool::D1(MySurf2,u2,v2,Pbid,TU,TV);

  TUTU = TU.Dot(TU);
  TVTV = TV.Dot(TV);
  TUTV = TU.Dot(TV);
  TgTU = Tg.Dot(TU);
  TgTV = Tg.Dot(TV);
  DIS  = TUTU * TVTV - TUTV * TUTV;

  DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ; 
  DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
  
  Tguv2.SetCoord(DeltaU,DeltaV);  MyTguv2 = Tguv2;

  return(Standard_True);
}
//--------------------------------------------------------------------------------
void ApproxInt_PrmPrmSvSurfaces::Pnt(const Standard_Real u1,
				     const Standard_Real v1,
				     const Standard_Real u2,
				     const Standard_Real v2,
				     gp_Pnt& P) { 
  gp_Pnt aP;
  gp_Vec aT;
  gp_Vec2d aTS1,aTS2;
  Standard_Real tu1=u1;
  Standard_Real tu2=u2;
  Standard_Real tv1=v1;
  Standard_Real tv2=v2;
#ifdef DEB
  Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
#else
  this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
#endif
  P=MyPnt;
}
//--------------------------------------------------------------------------------
Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Tangency(const Standard_Real u1,
						      const Standard_Real v1,
						      const Standard_Real u2,
						      const Standard_Real v2,
						      gp_Vec& T) { 
  gp_Pnt aP;
  gp_Vec aT;
  gp_Vec2d aTS1,aTS2;
  Standard_Real tu1=u1;
  Standard_Real tu2=u2;
  Standard_Real tv1=v1;
  Standard_Real tv2=v2;
  Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
  T=MyTg;
  return(t);
}
//--------------------------------------------------------------------------------
Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf1(const Standard_Real u1,
							     const Standard_Real v1,
							     const Standard_Real u2,
							     const Standard_Real v2,
							     gp_Vec2d& T) { 
  gp_Pnt aP;
  gp_Vec aT;
  gp_Vec2d aTS1,aTS2;
  Standard_Real tu1=u1;
  Standard_Real tu2=u2;
  Standard_Real tv1=v1;
  Standard_Real tv2=v2;
  Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
  T=MyTguv1;
  return(t);
}
//--------------------------------------------------------------------------------
Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf2(const Standard_Real u1,
							     const Standard_Real v1,
							     const Standard_Real u2,
							     const Standard_Real v2,
							     gp_Vec2d& T) { 
  gp_Pnt aP;
  gp_Vec aT;
  gp_Vec2d aTS1,aTS2;
  Standard_Real tu1=u1;
  Standard_Real tu2=u2;
  Standard_Real tv1=v1;
  Standard_Real tv2=v2;
  Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
  T=MyTguv2;
  return(t);
}
//--------------------------------------------------------------------------------


#if 0 
  //------------------------------------------------------------
  //-- Calcul de Tguv1
  //--
  ThePSurfaceTool::D1(MySurf1,u1,v1,P,TU,TV);
  
  TUTV = TU.Dot(TV);
  TgTU = Tg.Dot(TU);
  TgTV = Tg.Dot(TV);
  UmTUTV2 = 1.0 - TUTV * TUTV;
  
  DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ; 
  DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;

  Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
  
  Tguv1.Multiplied(Delta);  MyTguv1 = Tguv1;

  //------------------------------------------------------------
  //-- Calcul de Tguv2
  //--  
  ThePSurfaceTool::D1(MySurf2,u2,v2,P,TU,TV);

  TUTV = TU.Dot(TV);
  TgTU = Tg.Dot(TU);
  TgTV = Tg.Dot(TV);
  UmTUTV2 = 1.0 - TUTV * TUTV;
  
  DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ; 
  DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
  
  Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
  
  Tguv2.Multiplied(Delta);  MyTguv2 = Tguv2;

  return(Standard_True);
}
#endif
Commit	Line	Data
7fd59977	1	// File: ApproxInt_PrmPrmSvSurfaces.gxx
	2	// Created: Wed Mar 17 12:42:28 1993
	3	// Author: Laurent BUCHARD
	4	// <lbr@topsn3>
	5
	6	#define TOLTANGENCY 0.0000000001
	7
	8
	9	#include <TColStd_Array1OfReal.hxx>
	10	#include <math_FunctionSetRoot.hxx>
	11
	12	#define Debug(expr) cout<<" expr :"<<expr;
	13	#define MySurf1 MyIntersectionOn2S.Function().AuxillarSurface1()
	14	#define MySurf2 MyIntersectionOn2S.Function().AuxillarSurface2()
	15
	16
	17	//--------------------------------------------------------------------------------
	18	ApproxInt_PrmPrmSvSurfaces::ApproxInt_PrmPrmSvSurfaces( const ThePSurface& Surf1
	19	,const ThePSurface& Surf2):
	20	MyHasBeenComputed(Standard_False),
	21	MyHasBeenComputedbis(Standard_False),
	22	MyIntersectionOn2S(Surf1,Surf2,TOLTANGENCY)
	23	{
	24	}
	25	//--------------------------------------------------------------------------------
	26	Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Compute( Standard_Real& u1
	27	,Standard_Real& v1
	28	,Standard_Real& u2
	29	,Standard_Real& v2
	30	,gp_Pnt& P
	31	,gp_Vec& Tg
	32	,gp_Vec2d& Tguv1
	33	,gp_Vec2d& Tguv2) {
	34
	35	Standard_Real tu1=u1;
	36	Standard_Real tu2=u2;
	37	Standard_Real tv1=v1;
	38	Standard_Real tv2=v2;
	39
	40	if(MyHasBeenComputed) {
	41	if( (MyParOnS1.X()==u1)&&(MyParOnS1.Y()==v1)
	42	&&(MyParOnS2.X()==u2)&&(MyParOnS2.Y()==v2)) {
	43	return(MyIsTangent);
	44	}
	45	else if(MyHasBeenComputedbis == Standard_False) {
	46	MyTgbis = MyTg;
	47	MyTguv1bis = MyTguv1;
	48	MyTguv2bis = MyTguv2;
	49	MyPntbis = MyPnt;
	50	MyParOnS1bis = MyParOnS1;
	51	MyParOnS2bis = MyParOnS2;
	52	MyIsTangentbis = MyIsTangent;
	53	MyHasBeenComputedbis = MyHasBeenComputed;
	54	}
	55	}
	56	if(MyHasBeenComputedbis) {
	57	if( (MyParOnS1bis.X()==u1)&&(MyParOnS1bis.Y()==v1)
	58	&&(MyParOnS2bis.X()==u2)&&(MyParOnS2bis.Y()==v2)) {
	59
	60	gp_Vec TV(MyTg);
	61	gp_Vec2d TV1(MyTguv1);
	62	gp_Vec2d TV2(MyTguv2);
	63	gp_Pnt TP(MyPnt);
	64	gp_Pnt2d TP1(MyParOnS1);
65	gp_Pnt2d TP2(MyParOnS2);
66	Standard_Boolean TB=MyIsTangent;
67
68	MyTg = MyTgbis;
69	MyTguv1 = MyTguv1bis;
70	MyTguv2 = MyTguv2bis;
71	MyPnt = MyPntbis;
72	MyParOnS1 = MyParOnS1bis;
73	MyParOnS2 = MyParOnS2bis;
74	MyIsTangent = MyIsTangentbis;
75
76	MyTgbis = TV;
77	MyTguv1bis = TV1;
78	MyTguv2bis = TV2;
79	MyPntbis = TP;
80	MyParOnS1bis = TP1;
81	MyParOnS2bis = TP2;
82	MyIsTangentbis = TB;
83
84	return(MyIsTangent);
85	}
86	}
87
88
89	MyIsTangent = Standard_True;
90
91	static TColStd_Array1OfReal Param(1,4);
92	Param(1) = u1; Param(2) = v1;
93	Param(3) = u2; Param(4) = v2;
94	math_FunctionSetRoot Rsnld(MyIntersectionOn2S.Function());
7fd59977	95	MyIntersectionOn2S.Perform(Param,Rsnld);
7fd59977	96	if (!MyIntersectionOn2S.IsDone()) {
	97	MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
	98	return(Standard_False);
	99	}
	100	if (MyIntersectionOn2S.IsEmpty()) {
	101	MyIsTangent=Standard_False;
	102	//cout<<"\n----- Parametree Parametree : IsEmpty ds Compute "<<endl;
	103	//Debug(u1); Debug(u2); Debug(v1); Debug(v2); cout<<endl;
	104	MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
	105	return(Standard_False);
	106	}
	107	MyHasBeenComputed = Standard_True;
	108	MyPnt = P = MyIntersectionOn2S.Point().Value();
	109
	110	MyIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
	111	MyParOnS1.SetCoord(tu1,tv1);
	112	MyParOnS2.SetCoord(tu2,tv2);
	113
	114	if(MyIntersectionOn2S.IsTangent()) {
	115	MyIsTangent=Standard_False;
	116	MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
	117	return(Standard_False);
	118	}
	119	MyTg = Tg = MyIntersectionOn2S.Direction();
	120	MyTguv1 = Tguv1 = MyIntersectionOn2S.DirectionOnS1();
	121	MyTguv2 = Tguv2 = MyIntersectionOn2S.DirectionOnS2();
	122
	123	//----------------------------------------------------------------------
	124	//-- Si ( Tg ) TU et TV sont normes
	125	//--
	126	//-- On a Tg = DeltaU * TU + DeltaV * TV
	127	//--
	128	//-- soit : Tg.TU = DeltaU TU.TU + DeltaV TU.TV
	129	//-- Tg.TV = DeltaU TV.TU + DeltaV TV.TV
	130	//--
	131	//-- Donc :
	132	//--
	133	//-- Tg.TU TV.TV - Tg.TV * TU.TV
	134	//-- DeltaU = -------------------------------
	135	//-- TU.TU TV.TV - (TU.TV)**2
	136	//--
	137	//-- Tg.TV TU.TU - Tg.TU * TU.TV
	138	//-- DeltaV = -------------------------------
	139	//-- TU.TU TV.TV - (TU.TV)**2
	140	//--
	141	//--
	142
	143	Tg.Normalize(); MyTg = Tg;
	144
	145	Standard_Real DeltaU,DeltaV;
	146	gp_Vec TU,TV;
	147	gp_Pnt Pbid;
	148	Standard_Real TUTV,TgTU,TgTV,TUTU,TVTV,DIS;
	149	//------------------------------------------------------------
	150	//-- Calcul de Tguv1
	151	//--
	152	ThePSurfaceTool::D1(MySurf1,u1,v1,Pbid,TU,TV);
	153
	154	TUTU = TU.Dot(TU);
	155	TVTV = TV.Dot(TV);
	156	TUTV = TU.Dot(TV);
	157	TgTU = Tg.Dot(TU);
	158	TgTV = Tg.Dot(TV);
	159	DIS = TUTU * TVTV - TUTV * TUTV;
160
161	DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ;
162	DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
163
164	Tguv1.SetCoord(DeltaU,DeltaV); MyTguv1 = Tguv1;
165
166	//------------------------------------------------------------
167	//-- Calcul de Tguv2
168	//--
169	ThePSurfaceTool::D1(MySurf2,u2,v2,Pbid,TU,TV);
170
171	TUTU = TU.Dot(TU);
172	TVTV = TV.Dot(TV);
173	TUTV = TU.Dot(TV);
174	TgTU = Tg.Dot(TU);
175	TgTV = Tg.Dot(TV);
176	DIS = TUTU * TVTV - TUTV * TUTV;
177
178	DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ;
179	DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
180
181	Tguv2.SetCoord(DeltaU,DeltaV); MyTguv2 = Tguv2;
182
183	return(Standard_True);
184	}
185	//--------------------------------------------------------------------------------
186	void ApproxInt_PrmPrmSvSurfaces::Pnt(const Standard_Real u1,
187	const Standard_Real v1,
188	const Standard_Real u2,
189	const Standard_Real v2,
190	gp_Pnt& P) {
191	gp_Pnt aP;
192	gp_Vec aT;
193	gp_Vec2d aTS1,aTS2;
194	Standard_Real tu1=u1;
195	Standard_Real tu2=u2;
196	Standard_Real tv1=v1;
197	Standard_Real tv2=v2;
198	#ifdef DEB
199	Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
200	#else
201	this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
202	#endif
203	P=MyPnt;
204	}
205	//--------------------------------------------------------------------------------
206	Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Tangency(const Standard_Real u1,
207	const Standard_Real v1,
208	const Standard_Real u2,
209	const Standard_Real v2,
210	gp_Vec& T) {
211	gp_Pnt aP;
212	gp_Vec aT;
213	gp_Vec2d aTS1,aTS2;
214	Standard_Real tu1=u1;
215	Standard_Real tu2=u2;
216	Standard_Real tv1=v1;
217	Standard_Real tv2=v2;
218	Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
219	T=MyTg;
220	return(t);
221	}
222	//--------------------------------------------------------------------------------
223	Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf1(const Standard_Real u1,
224	const Standard_Real v1,
225	const Standard_Real u2,
226	const Standard_Real v2,
227	gp_Vec2d& T) {
228	gp_Pnt aP;
229	gp_Vec aT;
230	gp_Vec2d aTS1,aTS2;
231	Standard_Real tu1=u1;
232	Standard_Real tu2=u2;
233	Standard_Real tv1=v1;
234	Standard_Real tv2=v2;
235	Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
236	T=MyTguv1;
237	return(t);
238	}
239	//--------------------------------------------------------------------------------
240	Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf2(const Standard_Real u1,
241	const Standard_Real v1,
242	const Standard_Real u2,
243	const Standard_Real v2,
244	gp_Vec2d& T) {
245	gp_Pnt aP;
246	gp_Vec aT;
247	gp_Vec2d aTS1,aTS2;
248	Standard_Real tu1=u1;
249	Standard_Real tu2=u2;
250	Standard_Real tv1=v1;
251	Standard_Real tv2=v2;
252	Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
253	T=MyTguv2;
254	return(t);
255	}
256	//--------------------------------------------------------------------------------
257
258
259
260
261	#if 0
262	//------------------------------------------------------------
263	//-- Calcul de Tguv1
264	//--
265	ThePSurfaceTool::D1(MySurf1,u1,v1,P,TU,TV);
266
267	TUTV = TU.Dot(TV);
268	TgTU = Tg.Dot(TU);
269	TgTV = Tg.Dot(TV);
270	UmTUTV2 = 1.0 - TUTV * TUTV;
271
272	DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ;
273	DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
274
275	Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
276
277	Tguv1.Multiplied(Delta); MyTguv1 = Tguv1;
278
279	//------------------------------------------------------------
280	//-- Calcul de Tguv2
281	//--
282	ThePSurfaceTool::D1(MySurf2,u2,v2,P,TU,TV);
283
284	TUTV = TU.Dot(TV);
285	TgTU = Tg.Dot(TU);
286	TgTV = Tg.Dot(TV);
287	UmTUTV2 = 1.0 - TUTV * TUTV;
288
289	DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ;
290	DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
291
292	Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
293
294	Tguv2.Multiplied(Delta); MyTguv2 = Tguv2;
295
296	return(Standard_True);
297	}
298	#endif
299
300
301
302