1 // Created on: 1993-12-02
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
18 #include <Adaptor3d_HCurve.hxx>
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Blend_Point.hxx>
21 #include <BlendFunc.hxx>
22 #include <BlendFunc_Ruled.hxx>
25 #include <gp_Pnt2d.hxx>
27 #include <gp_Vec2d.hxx>
28 #include <math_Gauss.hxx>
29 #include <math_Matrix.hxx>
30 #include <Precision.hxx>
31 #include <Standard_DomainError.hxx>
32 #include <Standard_NotImplemented.hxx>
34 BlendFunc_Ruled::BlendFunc_Ruled(const Handle(Adaptor3d_HSurface)& S1,
35 const Handle(Adaptor3d_HSurface)& S2,
36 const Handle(Adaptor3d_HCurve)& C) :
38 surf1(S1),surf2(S2),curv(C),
39 istangent(Standard_True),
43 Standard_Integer BlendFunc_Ruled::NbEquations () const
48 void BlendFunc_Ruled::Set(const Standard_Real Param)
50 curv->D2(Param,ptgui,d1gui,d2gui);
51 normtg = d1gui.Magnitude();
52 nplan = d1gui.Normalized();
53 theD = - (nplan.XYZ().Dot(ptgui.XYZ()));
54 istangent = Standard_True;
57 void BlendFunc_Ruled::Set(const Standard_Real,
60 throw Standard_NotImplemented("BlendFunc_Ruled::Set");
63 void BlendFunc_Ruled::GetTolerance(math_Vector& Tolerance,
64 const Standard_Real Tol) const
66 Tolerance(1) = surf1->UResolution(Tol);
67 Tolerance(2) = surf1->VResolution(Tol);
68 Tolerance(3) = surf2->UResolution(Tol);
69 Tolerance(4) = surf2->VResolution(Tol);
72 void BlendFunc_Ruled::GetBounds(math_Vector& InfBound,
73 math_Vector& SupBound) const
75 InfBound(1) = surf1->FirstUParameter();
76 InfBound(2) = surf1->FirstVParameter();
77 InfBound(3) = surf2->FirstUParameter();
78 InfBound(4) = surf2->FirstVParameter();
79 SupBound(1) = surf1->LastUParameter();
80 SupBound(2) = surf1->LastVParameter();
81 SupBound(3) = surf2->LastUParameter();
82 SupBound(4) = surf2->LastVParameter();
84 for(Standard_Integer i = 1; i <= 4; i++){
85 if(!Precision::IsInfinite(InfBound(i)) &&
86 !Precision::IsInfinite(SupBound(i))) {
87 const Standard_Real range = (SupBound(i) - InfBound(i));
94 Standard_Boolean BlendFunc_Ruled::IsSolution(const math_Vector& Sol,
95 const Standard_Real Tol)
97 math_Vector valsol(1,4),secmember(1,4);
98 math_Matrix gradsol(1,4,1,4);
100 gp_Vec dnplan,d1u1,d1v1,d1u2,d1v2,temp,ns,ncrossns;
101 Standard_Real norm,ndotns,grosterme;
103 Values(Sol,valsol,gradsol);
104 if (Abs(valsol(1)) <= Tol &&
105 Abs(valsol(2)) <= Tol &&
106 Abs(valsol(3)) <= Tol &&
107 Abs(valsol(4)) <= Tol) {
110 // Calcul des tangentes
112 surf1->D1(Sol(1),Sol(2),pts1,d1u1,d1v1);
113 surf2->D1(Sol(3),Sol(4),pts2,d1u2,d1v2);
114 dnplan.SetLinearForm(1./normtg,d2gui,
115 -1./normtg*(nplan.Dot(d2gui)),nplan);
117 secmember(1) = normtg - dnplan.Dot(gp_Vec(ptgui,pts1));
118 secmember(2) = normtg - dnplan.Dot(gp_Vec(ptgui,pts2));
120 ns = d1u1.Crossed(d1v1);
121 ncrossns = nplan.Crossed(ns);
122 ndotns = nplan.Dot(ns);
123 norm = ncrossns.Magnitude();
125 // Derivee de nor1 par rapport au parametre sur la ligne guide
126 grosterme = ncrossns.Dot(dnplan.Crossed(ns))/norm/norm;
127 temp.SetLinearForm((dnplan.Dot(ns)-grosterme*ndotns)/norm,nplan,
132 secmember(3) = -(temp.Dot(gp_Vec(pts1,pts2)));
134 ns = d1u2.Crossed(d1v2);
135 ncrossns = nplan.Crossed(ns);
136 ndotns = nplan.Dot(ns);
137 norm = ncrossns.Magnitude();
139 // Derivee de nor2 par rapport au parametre sur la ligne guide
140 grosterme = ncrossns.Dot(dnplan.Crossed(ns))/norm/norm;
141 temp.SetLinearForm((dnplan.Dot(ns)-grosterme*ndotns)/norm,nplan,
145 secmember(4) = -(temp.Dot(gp_Vec(pts1,pts2)));
147 math_Gauss Resol(gradsol);
148 if (Resol.IsDone()) {
150 Resol.Solve(secmember);
152 tg1.SetLinearForm(secmember(1),d1u1,secmember(2),d1v1);
153 tg2.SetLinearForm(secmember(3),d1u2,secmember(4),d1v2);
154 tg12d.SetCoord(secmember(1),secmember(2));
155 tg22d.SetCoord(secmember(3),secmember(4));
156 istangent = Standard_False;
159 istangent = Standard_True;
161 return Standard_True;
163 istangent = Standard_True;
164 return Standard_False;
168 //=======================================================================
169 //function : GetMinimalDistance
171 //=======================================================================
173 Standard_Real BlendFunc_Ruled::GetMinimalDistance() const
178 Standard_Boolean BlendFunc_Ruled::Value(const math_Vector& X,
181 gp_Vec d1u1,d1v1,d1u2,d1v2;
182 surf1->D1(X(1),X(2),pts1,d1u1,d1v1);
183 surf2->D1(X(3),X(4),pts2,d1u2,d1v2);
185 const gp_Vec temp(pts1,pts2);
187 gp_Vec ns1 = d1u1.Crossed(d1v1);
188 gp_Vec ns2 = d1u2.Crossed(d1v2);
190 const Standard_Real norm1 = nplan.Crossed(ns1).Magnitude();
191 const Standard_Real norm2 = nplan.Crossed(ns2).Magnitude();
192 ns1.SetLinearForm(nplan.Dot(ns1)/norm1,nplan, -1./norm1,ns1);
193 ns2.SetLinearForm(nplan.Dot(ns2)/norm2,nplan, -1./norm2,ns2);
195 F(1) = (nplan.XYZ().Dot(pts1.XYZ())) + theD;
196 F(2) = (nplan.XYZ().Dot(pts2.XYZ())) + theD;
198 F(3) = temp.Dot(ns1);
199 F(4) = temp.Dot(ns2);
201 return Standard_True;
204 Standard_Boolean BlendFunc_Ruled::Derivatives(const math_Vector& X,
207 gp_Vec d1u1,d1v1,d1u2,d1v2;
208 gp_Vec d2u1,d2v1,d2uv1,d2u2,d2v2,d2uv2;
209 gp_Vec nor1,nor2,p1p2;
210 gp_Vec ns1,ns2,ncrossns1,ncrossns2,resul,temp;
212 Standard_Real norm1,norm2,ndotns1,ndotns2,grosterme;
214 surf1->D2(X(1),X(2),pts1,d1u1,d1v1,d2u1,d2v1,d2uv1);
215 surf2->D2(X(3),X(4),pts2,d1u2,d1v2,d2u2,d2v2,d2uv2);
217 D(1,1) = nplan.Dot(d1u1);
218 D(1,2) = nplan.Dot(d1v1);
224 D(2,3) = nplan.Dot(d1u2);
225 D(2,4) = nplan.Dot(d1v2);
227 ns1 = d1u1.Crossed(d1v1);
228 ns2 = d1u2.Crossed(d1v2);
229 ncrossns1 = nplan.Crossed(ns1);
230 ncrossns2 = nplan.Crossed(ns2);
231 norm1 = ncrossns1.Magnitude();
232 norm2 = ncrossns2.Magnitude();
234 ndotns1 = nplan.Dot(ns1);
235 ndotns2 = nplan.Dot(ns2);
237 nor1.SetLinearForm(ndotns1/norm1,nplan, -1./norm1,ns1);
238 nor2.SetLinearForm(ndotns2/norm2,nplan, -1./norm2,ns2);
240 p1p2 = gp_Vec(pts1,pts2);
242 // Derivee de nor1 par rapport a u1
243 temp = d2u1.Crossed(d1v1).Added(d1u1.Crossed(d2uv1));
244 grosterme = ncrossns1.Dot(nplan.Crossed(temp))/norm1/norm1;
245 resul.SetLinearForm(-(grosterme*ndotns1-nplan.Dot(temp))/norm1,nplan,
249 D(3,1) = -(d1u1.Dot(nor1)) + p1p2.Dot(resul);
251 // Derivee par rapport a v1
252 temp = d2uv1.Crossed(d1v1).Added(d1u1.Crossed(d2v1));
253 grosterme = ncrossns1.Dot(nplan.Crossed(temp))/norm1/norm1;
254 resul.SetLinearForm(-(grosterme*ndotns1-nplan.Dot(temp))/norm1,nplan,
258 D(3,2) = -(d1v1.Dot(nor1)) + p1p2.Dot(resul);
260 D(3,3) = d1u2.Dot(nor1);
261 D(3,4) = d1v2.Dot(nor1);
264 D(4,1) = -(d1u1.Dot(nor2));
265 D(4,2) = -(d1v1.Dot(nor2));
267 // Derivee de nor2 par rapport a u2
268 temp = d2u2.Crossed(d1v2).Added(d1u2.Crossed(d2uv2));
269 grosterme = ncrossns2.Dot(nplan.Crossed(temp))/norm2/norm2;
270 resul.SetLinearForm(-(grosterme*ndotns2-nplan.Dot(temp))/norm2,nplan,
274 D(4,3) = d1u2.Dot(nor2) + p1p2.Dot(resul);
276 // Derivee par rapport a v2
277 temp = d2uv2.Crossed(d1v2).Added(d1u2.Crossed(d2v2));
278 grosterme = ncrossns2.Dot(nplan.Crossed(temp))/norm2/norm2;
279 resul.SetLinearForm(-(grosterme*ndotns2-nplan.Dot(temp))/norm2,nplan,
283 D(4,4) = d1v2.Dot(nor2) + p1p2.Dot(resul);
285 return Standard_True;
289 Standard_Boolean BlendFunc_Ruled::Values(const math_Vector& X,
293 gp_Vec d1u1,d1v1,d1u2,d1v2;
294 gp_Vec d2u1,d2v1,d2uv1,d2u2,d2v2,d2uv2;
295 gp_Vec nor1,nor2,p1p2;
296 gp_Vec ns1,ns2,ncrossns1,ncrossns2,resul,temp;
298 Standard_Real norm1,norm2,ndotns1,ndotns2,grosterme;
300 surf1->D2(X(1),X(2),pts1,d1u1,d1v1,d2u1,d2v1,d2uv1);
301 surf2->D2(X(3),X(4),pts2,d1u2,d1v2,d2u2,d2v2,d2uv2);
303 p1p2 = gp_Vec(pts1,pts2);
305 ns1 = d1u1.Crossed(d1v1);
306 ns2 = d1u2.Crossed(d1v2);
307 ncrossns1 = nplan.Crossed(ns1);
308 ncrossns2 = nplan.Crossed(ns2);
309 norm1 = ncrossns1.Magnitude();
310 norm2 = ncrossns2.Magnitude();
312 ndotns1 = nplan.Dot(ns1);
313 ndotns2 = nplan.Dot(ns2);
315 nor1.SetLinearForm(ndotns1/norm1,nplan,-1./norm1,ns1);
316 nor2.SetLinearForm(ndotns2/norm2,nplan,-1./norm2,ns2);
318 F(1) = (nplan.XYZ().Dot(pts1.XYZ())) + theD;
319 F(2) = (nplan.XYZ().Dot(pts2.XYZ())) + theD;
320 F(3) = p1p2.Dot(nor1);
321 F(4) = p1p2.Dot(nor2);
323 D(1,1) = nplan.Dot(d1u1);
324 D(1,2) = nplan.Dot(d1v1);
330 D(2,3) = nplan.Dot(d1u2);
331 D(2,4) = nplan.Dot(d1v2);
334 // Derivee de nor1 par rapport a u1
335 temp = d2u1.Crossed(d1v1).Added(d1u1.Crossed(d2uv1));
336 grosterme = ncrossns1.Dot(nplan.Crossed(temp))/norm1/norm1;
337 resul.SetLinearForm(-(grosterme*ndotns1-nplan.Dot(temp))/norm1,nplan,
341 D(3,1) = -(d1u1.Dot(nor1)) + p1p2.Dot(resul);
343 // Derivee par rapport a v1
344 temp = d2uv1.Crossed(d1v1).Added(d1u1.Crossed(d2v1));
345 grosterme = ncrossns1.Dot(nplan.Crossed(temp))/norm1/norm1;
346 resul.SetLinearForm(-(grosterme*ndotns1-nplan.Dot(temp))/norm1,nplan,
350 D(3,2) = -(d1v1.Dot(nor1)) + p1p2.Dot(resul);
352 D(3,3) = d1u2.Dot(nor1);
353 D(3,4) = d1v2.Dot(nor1);
355 D(4,1) = -(d1u1.Dot(nor2));
356 D(4,2) = -(d1v1.Dot(nor2));
358 // Derivee de nor2 par rapport a u2
359 temp = d2u2.Crossed(d1v2).Added(d1u2.Crossed(d2uv2));
360 grosterme = ncrossns2.Dot(nplan.Crossed(temp))/norm2/norm2;
361 resul.SetLinearForm(-(grosterme*ndotns2-nplan.Dot(temp))/norm2,nplan,
365 D(4,3) = d1u2.Dot(nor2) + p1p2.Dot(resul);
367 // Derivee par rapport a v2
368 temp = d2uv2.Crossed(d1v2).Added(d1u2.Crossed(d2v2));
369 grosterme = ncrossns2.Dot(nplan.Crossed(temp))/norm2/norm2;
370 resul.SetLinearForm(-(grosterme*ndotns2-nplan.Dot(temp))/norm2,nplan,
374 D(4,4) = d1v2.Dot(nor2) + p1p2.Dot(resul);
376 return Standard_True;
380 void BlendFunc_Ruled::Tangent(const Standard_Real U1,
381 const Standard_Real V1,
382 const Standard_Real U2,
383 const Standard_Real V2,
393 surf2->D1(U2,V2,bid,d1u,d1v);
394 NmL = d1u.Crossed(d1v);
396 surf1->D1(U1,V1,bid,d1u,d1v);
397 NmF = ns1 = d1u.Crossed(d1v);
399 TgF = TgL = gp_Vec(pts1,pts2);
402 const gp_Pnt& BlendFunc_Ruled::PointOnS1 () const
407 const gp_Pnt& BlendFunc_Ruled::PointOnS2 () const
412 Standard_Boolean BlendFunc_Ruled::IsTangencyPoint () const
417 const gp_Vec& BlendFunc_Ruled::TangentOnS1 () const
420 throw Standard_DomainError("BlendFunc_Ruled::TangentOnS1");
424 const gp_Vec& BlendFunc_Ruled::TangentOnS2 () const
427 throw Standard_DomainError("BlendFunc_Ruled::TangentOnS2");
430 const gp_Vec2d& BlendFunc_Ruled::Tangent2dOnS1 () const
433 throw Standard_DomainError("BlendFunc_Ruled::Tangent2dOnS1");
437 const gp_Vec2d& BlendFunc_Ruled::Tangent2dOnS2 () const
440 throw Standard_DomainError("BlendFunc_Ruled::Tangent2dOnS2");
444 Standard_Boolean BlendFunc_Ruled::GetSection(const Standard_Real Param,
445 const Standard_Real U1,
446 const Standard_Real V1,
447 const Standard_Real U2,
448 const Standard_Real V2,
449 TColgp_Array1OfPnt& tabP,
450 TColgp_Array1OfVec& tabV)
453 Standard_Integer NbPoint=tabP.Length();
454 if (NbPoint != tabV.Length() || NbPoint < 2) {throw Standard_RangeError();}
456 Standard_Integer i, lowp = tabP.Lower(), lowv = tabV.Lower();
459 gp_Vec dnplan,d1u1,d1v1,d1u2,d1v2,temp,ns,ncrossns;
460 Standard_Real norm,ndotns,grosterme,lambda;
462 math_Vector sol(1,4),valsol(1,4),secmember(1,4);
463 math_Matrix gradsol(1,4,1,4);
465 curv->D2(Param,ptgui,d1gui,d2gui);
466 normtg = d1gui.Magnitude();
467 nplan = d1gui.Normalized();
468 theD = - (nplan.XYZ().Dot(ptgui.XYZ()));
470 sol(1) = U1; sol(2) = V1; sol(3) = U2; sol(4) = V2;
472 Values(sol,valsol,gradsol);
474 surf1->D1(sol(1),sol(2),pts1,d1u1,d1v1);
475 surf2->D1(sol(3),sol(4),pts2,d1u2,d1v2);
476 dnplan.SetLinearForm(1./normtg,d2gui,
477 -1./normtg*(nplan.Dot(d2gui)),nplan);
479 secmember(1) = normtg - dnplan.Dot(gp_Vec(ptgui,pts1));
480 secmember(2) = normtg - dnplan.Dot(gp_Vec(ptgui,pts2));
482 ns = d1u1.Crossed(d1v1);
483 ncrossns = nplan.Crossed(ns);
484 ndotns = nplan.Dot(ns);
485 norm = ncrossns.Magnitude();
487 // Derivee de nor1 par rapport au parametre sur la ligne guide
488 grosterme = ncrossns.Dot(dnplan.Crossed(ns))/norm/norm;
489 temp.SetLinearForm((dnplan.Dot(ns)-grosterme*ndotns)/norm,nplan,
494 secmember(3) = -(temp.Dot(gp_Vec(pts1,pts2)));
496 ns = d1u2.Crossed(d1v2);
497 ncrossns = nplan.Crossed(ns);
498 ndotns = nplan.Dot(ns);
499 norm = ncrossns.Magnitude();
501 // Derivee de nor2 par rapport au parametre sur la ligne guide
502 grosterme = ncrossns.Dot(dnplan.Crossed(ns))/norm/norm;
503 temp.SetLinearForm((dnplan.Dot(ns)-grosterme*ndotns)/norm,nplan,
507 secmember(4) = -(temp.Dot(gp_Vec(pts1,pts2)));
509 math_Gauss Resol(gradsol);
510 if (Resol.IsDone()) {
512 Resol.Solve(secmember);
514 tg1.SetLinearForm(secmember(1),d1u1,secmember(2),d1v1);
515 tg2.SetLinearForm(secmember(3),d1u2,secmember(4),d1v2);
518 tabP(lowp+NbPoint-1) = pts2;
521 tabV(lowv+NbPoint-1) = tg2;
523 for (i=2; i <= NbPoint-1; i++) {
525 lambda = (Standard_Real)(i-1)/(Standard_Real)(NbPoint-1);
526 tabP(lowp+i-1).SetXYZ((1.-lambda)*pts1.XYZ() + lambda*pts2.XYZ());
527 tabV(lowv+i-1).SetLinearForm(1.-lambda,tg1,lambda,tg2);
529 return Standard_True;
531 return Standard_False;
534 //=======================================================================
535 //function : IsRationnal
537 //=======================================================================
539 Standard_Boolean BlendFunc_Ruled::IsRational () const
541 return Standard_False;
545 //=======================================================================
546 //function : GetSectionSize
548 //=======================================================================
549 Standard_Real BlendFunc_Ruled::GetSectionSize() const
551 throw Standard_NotImplemented("BlendFunc_Ruled::GetSectionSize()");
554 //=======================================================================
555 //function : GetMinimalWeight
557 //=======================================================================
558 void BlendFunc_Ruled::GetMinimalWeight(TColStd_Array1OfReal& Weigths) const
562 //=======================================================================
563 //function : NbIntervals
565 //=======================================================================
567 Standard_Integer BlendFunc_Ruled::NbIntervals (const GeomAbs_Shape S) const
569 return curv->NbIntervals(BlendFunc::NextShape(S));
573 //=======================================================================
574 //function : Intervals
576 //=======================================================================
578 void BlendFunc_Ruled::Intervals (TColStd_Array1OfReal& T,
579 const GeomAbs_Shape S) const
581 curv->Intervals(T, BlendFunc::NextShape(S));
584 //=======================================================================
585 //function : GetShape
587 //=======================================================================
588 void BlendFunc_Ruled::GetShape(Standard_Integer& NbPoles,
589 Standard_Integer& NbKnots,
590 Standard_Integer& Degree,
591 Standard_Integer& NbPoles2d)
599 //=======================================================================
600 //function : GetTolerance
601 //purpose : Determine les Tolerance a utiliser dans les approximations.
602 //=======================================================================
603 void BlendFunc_Ruled::GetTolerance(const Standard_Real BoundTol,
609 Tol3d.Init(BoundTol);
612 void BlendFunc_Ruled::Knots(TColStd_Array1OfReal& TKnots)
614 TKnots(TKnots.Lower()) = 0.;
615 TKnots(TKnots.Upper()) = 1.;
618 void BlendFunc_Ruled::Mults(TColStd_Array1OfInteger& TMults)
620 TMults(TMults.Lower()) = TMults(TMults.Upper()) = 2;
623 Standard_Boolean BlendFunc_Ruled::Section(const Blend_Point& /*P*/,
624 TColgp_Array1OfPnt& /*Poles*/,
625 TColgp_Array1OfVec& /*DPoles*/,
626 TColgp_Array1OfVec& /*D2Poles*/,
627 TColgp_Array1OfPnt2d& /*Poles2d*/,
628 TColgp_Array1OfVec2d& /*DPoles2d*/,
629 TColgp_Array1OfVec2d& /*D2Poles2d*/,
630 TColStd_Array1OfReal& /*Weights*/,
631 TColStd_Array1OfReal& /*DWeights*/,
632 TColStd_Array1OfReal& /*D2Weights*/)
634 return Standard_False;
637 Standard_Boolean BlendFunc_Ruled::Section(const Blend_Point& P,
638 TColgp_Array1OfPnt& Poles,
639 TColgp_Array1OfVec& DPoles,
640 TColgp_Array1OfPnt2d& Poles2d,
641 TColgp_Array1OfVec2d& DPoles2d,
642 TColStd_Array1OfReal& Weights,
643 TColStd_Array1OfReal& DWeights)
645 Standard_Integer lowp = Poles.Lower(), lowp2d = Poles2d.Lower();
648 Poles(lowp) = P.PointOnS1();
649 Poles(lowp+1) = P.PointOnS2();
651 P.ParametersOnS1(u,v);
652 Poles2d(lowp2d).SetCoord(u,v);
653 P.ParametersOnS2(u,v);
654 Poles2d(lowp2d+1).SetCoord(u,v);
657 Weights(lowp+1) = 1.;
659 if (!P.IsTangencyPoint()) {
661 DPoles(lowp)= P.TangentOnS1();
662 DPoles(lowp+1)= P.TangentOnS2();
664 DPoles2d(lowp2d)= P.Tangent2dOnS1();
665 DPoles2d(lowp2d+1)= P.Tangent2dOnS2();
668 DWeights(lowp+1) = 0.;
670 return Standard_True;
673 return Standard_False;
677 void BlendFunc_Ruled::Section(const Blend_Point& P,
678 TColgp_Array1OfPnt& Poles,
679 TColgp_Array1OfPnt2d& Poles2d,
680 TColStd_Array1OfReal& Weights)
682 Standard_Integer lowp = Poles.Lower(), lowp2d = Poles2d.Lower();
685 Poles(lowp) = P.PointOnS1();
686 Poles(lowp+1) = P.PointOnS2();
688 P.ParametersOnS1(u,v);
689 Poles2d(lowp2d).SetCoord(u,v);
690 P.ParametersOnS2(u,v);
691 Poles2d(lowp2d+1).SetCoord(u,v);
694 Weights(lowp+1) = 1.;
699 gp_Ax1 BlendFunc_Ruled::AxeRot (const Standard_Real Prm)
702 gp_Vec dirax, dnplan;
705 curv->D2(Prm,ptgui,d1gui,d2gui);
707 normtg = d1gui.Magnitude();
708 nplan = d1gui.Normalized();
709 dnplan.SetLinearForm(1./normtg,d2gui,
710 -1./normtg*(nplan.Dot(d2gui)),nplan);
712 dirax = nplan.Crossed(dnplan);
713 axrot.SetDirection(dirax);
714 oriax.SetXYZ(ptgui.XYZ()+(normtg/dnplan.Magnitude())*dnplan.Normalized().XYZ());
715 axrot.SetLocation(oriax);
719 void BlendFunc_Ruled::Resolution(const Standard_Integer IC2d,
720 const Standard_Real Tol,
722 Standard_Real& TolV) const
725 TolU = surf1->UResolution(Tol);
726 TolV = surf1->VResolution(Tol);
729 TolU = surf2->UResolution(Tol);
730 TolV = surf2->VResolution(Tol);