OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0024763: Convertation of the generic classes to the non-generic. Part 6

Browse Source 
Next generic classes:

 "Contap_ArcFunction",
 "Contap_ContourGen",
 "Contap_HContToolGen",
 "Contap_HCurve2dToolGen",
 "Contap_Line",
 "Contap_Point",
 "Contap_SurfFunction",
 "Contap_SurfProps"

from "Contap" package were converted to the non-generic classes. Names of several classes were changed:

 "Contap_Contour",
 "Contap_HContTool",
 "Contap_HCurve2dTool",
 "Contap_Line",
 "Contap_Point"

 Also all instantiations of the "internal" classes of this classes were moved to the "Contap.cdl". And sources of the "Contap_ContourGen" class were merged to one .cxx file.
This commit is contained in:
dln 2014-03-25 11:55:53 +04:00 committed by apn
parent 424cd6bb64
commit e2065c2fb9
30 changed files with 2753 additions and 2906 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/Contap/Contap.cdl
View File

@ -16,72 +16,82 @@
package Contap package Contap
---Purpose: ---Purpose:
uses Standard,StdFail,MMgt, GeomAbs, TopAbs, TCollection, gp, TColgp, uses Standard,StdFail,MMgt, GeomAbs, TopAbs, TCollection, gp, TColgp,
math, IntSurf, IntStart, IntWalk, math, IntSurf, IntStart, IntWalk,
Geom2d, TColStd, Geom, Adaptor3d, Adaptor2d Geom2d, TColStd, Geom, Adaptor3d, Adaptor2d
is is
generic class Point;
generic class Line;
generic class SurfFunction; class Point;
generic class ArcFunction;
generic class SurfProps;
generic class ContourGen, ThePoint,TheSequenceOfPoint,TheHSequenceOfPoint, class Line;
TheLine, TheSequenceOfLine,
TheSurfProps, TheSurfFunction, TheArcFunction,
TheSearch, TheIWalking, TheSearchInside;
---TheLineConstructor;
class ContAna; class SurfFunction;
class ArcFunction;
class SurfProps;
class Contour;
class TheSequenceOfPoint instantiates Sequence from TCollection (Point from Contap);
class TheHSequenceOfPoint instantiates HSequence from TCollection
(Point from Contap,
TheSequenceOfPoint from Contap);
class TheSequenceOfLine instantiates Sequence from TCollection(Line from Contap);
class TheSearch instantiates SearchOnBoundaries from IntStart
(HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HCurve2dTool from Contap,
HContTool from Contap,
TopolTool from Adaptor3d,
ArcFunction from Contap);
class TheIWalking instantiates IWalking from IntWalk
(PathPoint from IntSurf,
PathPointTool from IntSurf,
SequenceOfPathPoint from IntSurf,
InteriorPoint from IntSurf,
InteriorPointTool from IntSurf,
SequenceOfInteriorPoint from IntSurf,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
SurfFunction from Contap);
class TheSearchInside instantiates SearchInside from IntStart
(HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
TopolTool from Adaptor3d,
HContTool from Contap,
SurfFunction from Contap);
class ContAna;
enumeration TFunction is enumeration TFunction is
ContourStd, ContourStd,
ContourPrs, ContourPrs,
DraftStd, DraftStd,
DraftPrs DraftPrs
end TFunction; end TFunction;
enumeration IType is -- a replacer dans IntSurf et fusionner avec IntPatch enumeration IType is -- a replacer dans IntSurf et fusionner avec IntPatch
-- type of the line of contour -- type of the line of contour
Lin, -- pour conflit avec deferred class Line
Lin, -- pour conflit avec deferred class Line Circle,
Circle,
Walking, Walking,
Restriction Restriction
end IType; end IType;
generic class HContToolGen;
generic class HCurve2dToolGen;
class HCurve2dTool instantiates
HCurve2dToolGen from Contap (
HCurve2d from Adaptor2d);
class HContTool instantiates
HContToolGen from Contap (
HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d);
class Contour instantiates ContourGen from Contap
(HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d,
HContTool from Contap,
TopolTool from Adaptor3d);
class HContTool;
class HCurve2dTool;
end Contap; end Contap;

30
src/Contap/Contap_ArcFunction.cdl
View File

@ -14,25 +14,21 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class ArcFunction from Contap class ArcFunction from Contap inherits FunctionWithDerivative from math
(TheArc as any;
TheSurface as any;
TheArcTool as any;
TheSurfaceTool as any;
TheSurfProps as any; -- as SurfProps from Contap(TheSurface,
-- TheSurfaceTool)
TheContTool as any) -- as ContTool from Contap()
inherits FunctionWithDerivative from math
uses Pnt from gp, uses Pnt from gp,
Dir from gp, Dir from gp,
SequenceOfPnt from TColgp, SequenceOfPnt from TColgp,
TFunction from Contap, TFunction from Contap,
--modified by NIZNHY-PKV Thu Mar 29 16:52:28 2001 f --modified by NIZNHY-PKV Thu Mar 29 16:52:28 2001 f
Quadric from IntSurf Quadric from IntSurf,
--modified by NIZNHY-PKV Thu Mar 29 16:52:31 2001 t --modified by NIZNHY-PKV Thu Mar 29 16:52:31 2001
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d,
SurfProps from Contap,
HContTool from Contap
is is
@ -42,7 +38,7 @@ is
returns ArcFunction from Contap; returns ArcFunction from Contap;
Set(me: in out; S: TheSurface) Set(me: in out; S: HSurface from Adaptor3d)
is static; is static;
@ -70,7 +66,7 @@ is
is static; is static;
Set(me: in out; A: TheArc) Set(me: in out; A: HCurve2d from Adaptor2d)
---C++: inline ---C++: inline
is static; is static;
@ -121,8 +117,8 @@ is
fields fields
myArc : TheArc; myArc : HCurve2d from Adaptor2d;
mySurf : TheSurface; mySurf : HSurface from Adaptor3d;
myMean : Real from Standard; myMean : Real from Standard;
myType : TFunction from Contap; myType : TFunction from Contap;
myDir : Dir from gp; myDir : Dir from gp;

93
src/Contap/Contap_ArcFunction.gxx → src/Contap/Contap_ArcFunction.cxx
View File

@ -14,31 +14,34 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <gp_Pnt2d.hxx> #include <Contap_ArcFunction.ixx>
#include <gp_Vec2d.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_SurfProps.hxx>
#include <Contap_HCurve2dTool.hxx>
Contap_ArcFunction::Contap_ArcFunction (): Contap_ArcFunction::Contap_ArcFunction ():
myMean(1.), myMean(1.),
myType(Contap_ContourStd), myType(Contap_ContourStd),
myDir(0.,0.,1.) myDir(0.,0.,1.)
{} {}
void Contap_ArcFunction::Set(const TheSurface& S) void Contap_ArcFunction::Set(const Handle(Adaptor3d_HSurface)& S)
{ {
mySurf = S; mySurf = S;
Standard_Integer i; Standard_Integer i;
Standard_Integer nbs = TheContTool::NbSamplePoints(S); Standard_Integer nbs = Contap_HContTool::NbSamplePoints(S);
Standard_Real U,V; Standard_Real U,V;
// gp_Vec d1u,d1v; // gp_Vec d1u,d1v;
gp_Vec norm; gp_Vec norm;
if (nbs > 0) { if (nbs > 0) {
myMean = 0.; myMean = 0.;
for (i = 1; i <= nbs; i++) { for (i = 1; i <= nbs; i++) {
TheContTool::SamplePoint(S,i,U,V); Contap_HContTool::SamplePoint(S,i,U,V);
// TheSurfaceTool::D1(S,U,V,solpt,d1u,d1v); // Adaptor3d_HSurfaceTool::D1(S,U,V,solpt,d1u,d1v);
// myMean = myMean + d1u.Crossed(d1v).Magnitude(); // myMean = myMean + d1u.Crossed(d1v).Magnitude();
TheSurfProps::Normale(S,U,V,solpt,norm); Contap_SurfProps::Normale(S,U,V,solpt,norm);
myMean = myMean + norm.Magnitude(); myMean = myMean + norm.Magnitude();
} }
myMean = myMean / ((Standard_Real)nbs); myMean = myMean / ((Standard_Real)nbs);
@ -47,14 +50,14 @@ void Contap_ArcFunction::Set(const TheSurface& S)
Standard_Boolean Contap_ArcFunction::Value (const Standard_Real U, Standard_Boolean Contap_ArcFunction::Value (const Standard_Real U,
Standard_Real& F) Standard_Real& F)
{ {
//gp_Vec d1u,d1v; //gp_Vec d1u,d1v;
gp_Pnt2d pt2d(TheArcTool::Value(myArc,U)); gp_Pnt2d pt2d(Contap_HCurve2dTool::Value(myArc,U));
// TheSurfaceTool::D1(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v); // Adaptor3d_HSurfaceTool::D1(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v);
// gp_Vec norm(d1u.Crossed(d1v)); // gp_Vec norm(d1u.Crossed(d1v));
gp_Vec norm; gp_Vec norm;
TheSurfProps::Normale(mySurf,pt2d.X(),pt2d.Y(),solpt,norm); Contap_SurfProps::Normale(mySurf,pt2d.X(),pt2d.Y(),solpt,norm);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
@ -82,22 +85,22 @@ Standard_Boolean Contap_ArcFunction::Value (const Standard_Real U,
Standard_Boolean Contap_ArcFunction::Derivative (const Standard_Real U, Standard_Boolean Contap_ArcFunction::Derivative (const Standard_Real U,
Standard_Real& D) Standard_Real& D)
{ {
gp_Pnt2d pt2d; gp_Pnt2d pt2d;
gp_Vec2d d2d; gp_Vec2d d2d;
Standard_Real dfu =0.,dfv =0.; Standard_Real dfu =0.,dfv =0.;
// gp_Vec d1u,d1v,d2u,d2v,d2uv; // gp_Vec d1u,d1v,d2u,d2v,d2uv;
TheArcTool::D1(myArc,U,pt2d,d2d); Contap_HCurve2dTool::D1(myArc,U,pt2d,d2d);
// TheSurfaceTool::D2(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v,d2u,d2v,d2uv); // Adaptor3d_HSurfaceTool::D2(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v,d2u,d2v,d2uv);
gp_Vec norm,dnu,dnv; gp_Vec norm,dnu,dnv;
TheSurfProps::NormAndDn(mySurf,pt2d.X(),pt2d.Y(),solpt,norm,dnu,dnv); Contap_SurfProps::NormAndDn(mySurf,pt2d.X(),pt2d.Y(),solpt,norm,dnu,dnv);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
// dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean; // dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
// dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean; // dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
dfu = (dnu.Dot(myDir))/myMean; dfu = (dnu.Dot(myDir))/myMean;
dfv = (dnv.Dot(myDir))/myMean; dfv = (dnv.Dot(myDir))/myMean;
} }
@ -105,21 +108,21 @@ Standard_Boolean Contap_ArcFunction::Derivative (const Standard_Real U,
case Contap_ContourPrs: case Contap_ContourPrs:
{ {
gp_Vec Ep(myEye,solpt); gp_Vec Ep(myEye,solpt);
// dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean; // dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
// dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean; // dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
dfu = (dnu.Dot(Ep))/myMean; dfu = (dnu.Dot(Ep))/myMean;
dfv = (dnv.Dot(Ep))/myMean; dfv = (dnv.Dot(Ep))/myMean;
} }
break; break;
case Contap_DraftStd: case Contap_DraftStd:
{ {
/* /*
gp_Vec norm(d1u.Crossed(d1v).Normalized()); gp_Vec norm(d1u.Crossed(d1v).Normalized());
gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv)); gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
dfu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; dfu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v); dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
dfv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; dfv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
*/ */
norm.Normalized(); norm.Normalized();
dfu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean; dfu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
dfv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean; dfv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
@ -135,25 +138,25 @@ Standard_Boolean Contap_ArcFunction::Derivative (const Standard_Real U,
} }
Standard_Boolean Contap_ArcFunction::Values (const Standard_Real U, Standard_Boolean Contap_ArcFunction::Values (const Standard_Real U,
Standard_Real& F, Standard_Real& F,
Standard_Real& D) Standard_Real& D)
{ {
gp_Pnt2d pt2d; gp_Pnt2d pt2d;
gp_Vec2d d2d; gp_Vec2d d2d;
Standard_Real dfu =0.,dfv =0.; Standard_Real dfu =0.,dfv =0.;
// gp_Vec d1u,d1v,d2u,d2v,d2uv; // gp_Vec d1u,d1v,d2u,d2v,d2uv;
TheArcTool::D1(myArc,U,pt2d,d2d); Contap_HCurve2dTool::D1(myArc,U,pt2d,d2d);
// TheSurfaceTool::D2(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v,d2u,d2v,d2uv); // Adaptor3d_HSurfaceTool::D2(mySurf,pt2d.X(),pt2d.Y(),solpt,d1u,d1v,d2u,d2v,d2uv);
// gp_Vec norm(d1u.Crossed(d1v)); // gp_Vec norm(d1u.Crossed(d1v));
gp_Vec norm,dnu,dnv; gp_Vec norm,dnu,dnv;
TheSurfProps::NormAndDn(mySurf,pt2d.X(),pt2d.Y(),solpt,norm,dnu,dnv); Contap_SurfProps::NormAndDn(mySurf,pt2d.X(),pt2d.Y(),solpt,norm,dnu,dnv);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
F = (norm.Dot(myDir))/myMean; F = (norm.Dot(myDir))/myMean;
// dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean; // dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
// dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean; // dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
dfu = (dnu.Dot(myDir))/myMean; dfu = (dnu.Dot(myDir))/myMean;
dfv = (dnv.Dot(myDir))/myMean; dfv = (dnv.Dot(myDir))/myMean;
} }
@ -162,8 +165,8 @@ Standard_Boolean Contap_ArcFunction::Values (const Standard_Real U,
{ {
gp_Vec Ep(myEye,solpt); gp_Vec Ep(myEye,solpt);
F = (norm.Dot(Ep))/myMean; F = (norm.Dot(Ep))/myMean;
// dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean; // dfu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
// dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean; // dfv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
dfu = (dnu.Dot(Ep))/myMean; dfu = (dnu.Dot(Ep))/myMean;
dfv = (dnv.Dot(Ep))/myMean; dfv = (dnv.Dot(Ep))/myMean;
} }
@ -172,12 +175,12 @@ Standard_Boolean Contap_ArcFunction::Values (const Standard_Real U,
{ {
F = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean; F = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
norm.Normalize(); norm.Normalize();
/* /*
gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv)); gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
dfu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; dfu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v); dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
dfv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; dfv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
*/ */
dfu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean; dfu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
dfv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean; dfv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
} }
@ -200,9 +203,9 @@ Standard_Integer Contap_ArcFunction::GetStateNumber ()
Standard_Integer Contap_ArcFunction::NbSamples () const Standard_Integer Contap_ArcFunction::NbSamples () const
{ {
return Max(Max(TheContTool::NbSamplesU(mySurf,0.,0.), return Max(Max(Contap_HContTool::NbSamplesU(mySurf,0.,0.),
TheContTool::NbSamplesV(mySurf,0.,0.)), Contap_HContTool::NbSamplesV(mySurf,0.,0.)),
TheContTool::NbSamplesOnArc(myArc)); Contap_HContTool::NbSamplesOnArc(myArc));
} }
//modified by NIZNHY-PKV Thu Mar 29 16:53:07 2001f //modified by NIZNHY-PKV Thu Mar 29 16:53:07 2001f
@ -210,7 +213,7 @@ Standard_Integer Contap_ArcFunction::NbSamples () const
//function : Quadric //function : Quadric
//purpose : returns empty Quadric //purpose : returns empty Quadric
//======================================================================= //=======================================================================
const IntSurf_Quadric& Contap_ArcFunction::Quadric() const const IntSurf_Quadric& Contap_ArcFunction::Quadric() const
{ {
return(myQuad); return(myQuad);
} }

2
src/Contap/Contap_ArcFunction.lxx
View File

@ -42,7 +42,7 @@ inline void Contap_ArcFunction::Set(const gp_Pnt& Eye)
myEye = Eye; myEye = Eye;
} }
inline void Contap_ArcFunction::Set(const TheArc& A) inline void Contap_ArcFunction::Set(const Handle(Adaptor2d_HCurve2d)& A)
{ {
myArc = A; myArc = A;
seqpt.Clear(); seqpt.Clear();

135
src/Contap/Contap_ContourGen.cdl → src/Contap/Contap_Contour.cdl
View File

@ -14,16 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class ContourGen from Contap class Contour from Contap
(TheVertex as any;
TheArc as any;
TheSurface as any;
TheArcTool as any;
TheSurfaceTool as any;
TheContTool as any; -- as ContTool from Contap(TheVertex,TheArc,
-- TheSurface)
TheTopolTool as Transient)
uses PathPoint from IntSurf, uses PathPoint from IntSurf,
PathPointTool from IntSurf, PathPointTool from IntSurf,
@ -32,130 +23,70 @@ uses PathPoint from IntSurf,
InteriorPointTool from IntSurf, InteriorPointTool from IntSurf,
SequenceOfInteriorPoint from IntSurf, SequenceOfInteriorPoint from IntSurf,
Pnt from gp, Pnt from gp,
Vec from gp Vec from gp,
Point from Contap,
Line from Contap,
SurfFunction from Contap,
ArcFunction from Contap,
TheSequenceOfLine from Contap,
TheSearch from Contap,
TheSearchInside from Contap,
HSurface from Adaptor3d,
TopolTool from Adaptor3d
raises NotDone from StdFail, raises NotDone from StdFail,
OutOfRange from Standard, OutOfRange from Standard,
ConstructionError from Standard ConstructionError from Standard
class ThePoint instantiates Point from Contap
(TheVertex,
TheArc);
class TheSequenceOfPoint instantiates Sequence from TCollection
(ThePoint);
class TheHSequenceOfPoint instantiates HSequence from TCollection
(ThePoint,TheSequenceOfPoint);
class TheLine instantiates Line from Contap
(TheVertex,
TheArc,
ThePoint,
TheHSequenceOfPoint);
class TheSequenceOfLine instantiates Sequence from TCollection
(TheLine);
class TheSurfProps instantiates SurfProps from Contap
(TheSurface,
TheSurfaceTool);
class TheSurfFunction instantiates SurfFunction from Contap
(TheSurface,
TheSurfaceTool,
TheSurfProps from Contap,
TheContTool);
class TheArcFunction instantiates ArcFunction from Contap
(TheArc,
TheSurface,
TheArcTool,
TheSurfaceTool,
TheSurfProps from Contap,
TheContTool);
class TheSearch instantiates SearchOnBoundaries from IntStart
(TheVertex,
TheArc,
TheArcTool,
TheContTool,
TheTopolTool,
TheArcFunction from Contap);
class TheIWalking instantiates IWalking from IntWalk
(PathPoint from IntSurf,
PathPointTool from IntSurf,
SequenceOfPathPoint from IntSurf,
InteriorPoint from IntSurf,
InteriorPointTool from IntSurf,
SequenceOfInteriorPoint from IntSurf,
TheSurface,
TheSurfaceTool,
TheSurfFunction from Contap);
class TheSearchInside instantiates SearchInside from IntStart
(TheSurface,
TheSurfaceTool,
TheTopolTool,
TheContTool,
TheSurfFunction from Contap);
is is
Create Create
returns ContourGen from Contap; returns Contour from Contap;
Create(Direction: Vec from gp) Create(Direction: Vec from gp)
returns ContourGen from Contap; returns Contour from Contap;
Create(Direction: Vec from gp; Angle: Real from Standard) Create(Direction: Vec from gp; Angle: Real from Standard)
returns ContourGen from Contap; returns Contour from Contap;
Create(Eye: Pnt from gp) Create(Eye: Pnt from gp)
returns ContourGen from Contap; returns Contour from Contap;
Create(Surf: TheSurface; Domain: TheTopolTool; Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp) Direction: Vec from gp)
---Purpose: Creates the contour in a given direction. ---Purpose: Creates the contour in a given direction.
returns ContourGen from Contap; returns Contour from Contap;
Create(Surf: TheSurface; Domain: TheTopolTool; Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp; Angle: Real from Standard) Direction: Vec from gp; Angle: Real from Standard)
---Purpose: Creates the contour in a given direction. ---Purpose: Creates the contour in a given direction.
returns ContourGen from Contap; returns Contour from Contap;
Create(Surf: TheSurface; Domain: TheTopolTool; Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Eye: Pnt from gp) Eye: Pnt from gp)
---Purpose: Creates the contour for a perspective view. ---Purpose: Creates the contour for a perspective view.
returns ContourGen from Contap; returns Contour from Contap;
Perform(me: in out; Surf: TheSurface; Domain: TheTopolTool) Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d)
---Purpose: Creates the contour in a given direction. ---Purpose: Creates the contour in a given direction.
@ -163,7 +94,7 @@ is
is static; is static;
Perform(me: in out; Surf: TheSurface; Domain: TheTopolTool; Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp) Direction: Vec from gp)
---Purpose: Creates the contour in a given direction. ---Purpose: Creates the contour in a given direction.
@ -171,7 +102,7 @@ is
is static; is static;
Perform(me: in out; Surf: TheSurface; Domain: TheTopolTool; Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp; Angle: Real from Standard) Direction: Vec from gp; Angle: Real from Standard)
---Purpose: Creates the contour in a given direction. ---Purpose: Creates the contour in a given direction.
@ -179,7 +110,7 @@ is
is static; is static;
Perform(me: in out; Surf: TheSurface; Domain: TheTopolTool; Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Eye: Pnt from gp) Eye: Pnt from gp)
---Purpose: Creates the contour for a perspective view. ---Purpose: Creates the contour for a perspective view.
@ -234,7 +165,7 @@ is
Line(me; Index: Integer from Standard) Line(me; Index: Integer from Standard)
returns TheLine from Contap returns Line from Contap
---C++: return const& ---C++: return const&
---C++: inline ---C++: inline
@ -245,7 +176,7 @@ is
SurfaceFunction(me : in out) SurfaceFunction(me : in out)
returns TheSurfFunction returns SurfFunction
---Purpose: Returns a reference on the internal ---Purpose: Returns a reference on the internal
-- SurfaceFunction. This is used to compute tangents -- SurfaceFunction. This is used to compute tangents
-- on the lines. -- on the lines.
@ -254,12 +185,12 @@ is
is static; is static;
Perform(me: in out; Domain: TheTopolTool) Perform(me: in out; Domain: TopolTool from Adaptor3d)
is static private; is static private;
PerformAna(me: in out; Domain: TheTopolTool) PerformAna(me: in out; Domain: TopolTool from Adaptor3d)
is static private; is static private;
@ -270,8 +201,8 @@ fields
slin : TheSequenceOfLine from Contap; slin : TheSequenceOfLine from Contap;
solrst : TheSearch from Contap; solrst : TheSearch from Contap;
solins : TheSearchInside from Contap; solins : TheSearchInside from Contap;
mySFunc : TheSurfFunction from Contap; mySFunc : SurfFunction from Contap;
myAFunc : TheArcFunction from Contap; myAFunc : ArcFunction from Contap;
modeset : Boolean from Standard; modeset : Boolean from Standard;
end ContourGen; end Contour;

2146
src/Contap/Contap_Contour.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

14
src/Contap/Contap_ContourGen.lxx → src/Contap/Contap_Contour.lxx
View File

@ -16,31 +16,31 @@
#include <StdFail_NotDone.hxx> #include <StdFail_NotDone.hxx>
inline Standard_Boolean Contap_ContourGen::IsDone () const inline Standard_Boolean Contap_Contour::IsDone () const
{ {
return done; return done;
} }
inline Standard_Boolean Contap_ContourGen::IsEmpty () const inline Standard_Boolean Contap_Contour::IsEmpty () const
{ {
return NbLines()==0; return NbLines()==0;
} }
inline Standard_Integer Contap_ContourGen::NbLines () const inline Standard_Integer Contap_Contour::NbLines () const
{ {
if (!done) {StdFail_NotDone::Raise();} if (!done) {StdFail_NotDone::Raise();}
return slin.Length(); return slin.Length();
} }
inline const Contap_TheLine & inline const Contap_Line &
Contap_ContourGen::Line (const Standard_Integer Index) const Contap_Contour::Line (const Standard_Integer Index) const
{ {
if (!done) {StdFail_NotDone::Raise();} if (!done) {StdFail_NotDone::Raise();}
return slin(Index); return slin(Index);
} }
inline Contap_TheSurfFunction & inline Contap_SurfFunction &
Contap_ContourGen::SurfaceFunction () Contap_Contour::SurfaceFunction ()
{ {
if (!done) {StdFail_NotDone::Raise();} if (!done) {StdFail_NotDone::Raise();}
return mySFunc; return mySFunc;

31
src/Contap/Contap_ContourGen.gxx
View File

@ -1,31 +0,0 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-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 <ElCLib.hxx>
#include <gp_Pln.hxx>
#include <gp_Sphere.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Cone.hxx>
#include <gp_Lin.hxx>
#include <gp_Circ.hxx>
#include <Contap_ContAna.hxx>
#include <math_FunctionSetRoot.hxx>
#include <IntSurf.hxx>
#include <Contap_ContourGen_1.gxx>
#include <Contap_ContourGen_2.gxx>
#include <Contap_ContourGen_3.gxx>

167
src/Contap/Contap_ContourGen_1.gxx
View File

@ -1,167 +0,0 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-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 <Standard_ConstructionError.hxx>
Contap_ContourGen::Contap_ContourGen () :
done(Standard_False),modeset(Standard_False)
{}
Contap_ContourGen::Contap_ContourGen (const gp_Vec& Direction) :
done(Standard_False),modeset(Standard_True)
{
mySFunc.Set(Direction);
myAFunc.Set(Direction);
}
Contap_ContourGen::Contap_ContourGen (const gp_Vec& Direction,
const Standard_Real Angle) :
done(Standard_False),modeset(Standard_True)
{
mySFunc.Set(Direction,Angle);
myAFunc.Set(Direction,Angle);
}
Contap_ContourGen::Contap_ContourGen (const gp_Pnt& Eye) :
done(Standard_False),modeset(Standard_True)
{
mySFunc.Set(Eye);
myAFunc.Set(Eye);
}
Contap_ContourGen::Contap_ContourGen (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Vec& Direction) :
done(Standard_False),modeset(Standard_True)
{
Perform(Surf,Domain,Direction);
}
Contap_ContourGen::Contap_ContourGen (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Vec& Direction,
const Standard_Real Angle) :
done(Standard_False),modeset(Standard_True)
{
Perform(Surf,Domain,Direction,Angle);
}
Contap_ContourGen::Contap_ContourGen (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Pnt& Eye) :
done(Standard_False),modeset(Standard_True)
{
Perform(Surf,Domain,Eye);
}
void Contap_ContourGen::Init (const gp_Vec& Direction)
{
done = Standard_False;
modeset = Standard_True;
mySFunc.Set(Direction);
myAFunc.Set(Direction);
}
void Contap_ContourGen::Init(const gp_Vec& Direction,
const Standard_Real Angle)
{
done = Standard_False;
modeset = Standard_True;
mySFunc.Set(Direction,Angle);
myAFunc.Set(Direction,Angle);
}
void Contap_ContourGen::Init (const gp_Pnt& Eye)
{
done = Standard_False;
modeset = Standard_True;
mySFunc.Set(Eye);
myAFunc.Set(Eye);
}
void Contap_ContourGen::Perform (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain)
{
if (!modeset) {Standard_ConstructionError::Raise();}
mySFunc.Set(Surf);
myAFunc.Set(Surf);
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
switch (typS) {
case GeomAbs_Plane:
case GeomAbs_Sphere:
case GeomAbs_Cylinder:
case GeomAbs_Cone:
{
PerformAna(Domain); //Surf,Domain,Direction,0.,gp_Pnt(0.,0.,0.),1);
}
break;
default:
{
Perform(Domain); //Surf,Domain,Direction,0.,gp_Pnt(0.,0.,0.),1);
}
break;
}
}
void Contap_ContourGen::Perform (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Vec& Direction)
{
Init(Direction);
Perform(Surf,Domain);
}
void Contap_ContourGen::Perform (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Vec& Direction,
const Standard_Real Angle)
{
Init(Direction,Angle);
Perform(Surf,Domain);
}
void Contap_ContourGen::Perform (const TheSurface& Surf,
const Handle(TheTopolTool)& Domain,
const gp_Pnt& Eye)
{
Init(Eye);
Perform(Surf,Domain);
}

1577
src/Contap/Contap_ContourGen_2.gxx
View File

File diff suppressed because it is too large Load Diff

442
src/Contap/Contap_ContourGen_3.gxx
View File

@ -1,442 +0,0 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-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.
#define Tolpetit 1.e-10 // pour dist au carre
#include <ElSLib.hxx>
#include <TColStd_SequenceOfInteger.hxx>
static Standard_Boolean FindLine(Contap_TheLine& Line,
const TheSurface& Surf,
const gp_Pnt2d& Pt2d,
gp_Pnt& Ptref,
Standard_Real& Paramin,
gp_Vec& Tgmin,
gp_Vec& Norm)
{
// Standard_Integer i;
gp_Pnt pt,ptmin;
gp_Vec tg;
Standard_Real para,dist;
Standard_Real dismin = RealLast();
Contap_TheSurfProps::Normale(Surf,Pt2d.X(),Pt2d.Y(),Ptref,Norm);
if (Line.TypeContour() == Contap_Lin) {
gp_Lin lin(Line.Line());
para = ElCLib::Parameter(lin,Ptref);
ElCLib::D1(para,lin,pt,tg);
dist = pt.Distance(Ptref) + Abs(Norm.Dot(lin.Direction()));
}
else { // Contap__Circle
gp_Circ cir(Line.Circle());
para = ElCLib::Parameter(cir,Ptref);
ElCLib::D1(para,cir,pt,tg);
dist = pt.Distance(Ptref)+Abs(Norm.Dot(tg/cir.Radius()));
}
if (dist < dismin) {
dismin = dist;
Paramin = para;
ptmin = pt;
Tgmin = tg;
}
if (ptmin.SquareDistance(Ptref) <= Tolpetit) {
return Standard_True;
}
else {
return Standard_False;
}
}
static void PutPointsOnLine (const Contap_TheSearch& solrst,
const TheSurface& Surf,
Contap_TheSequenceOfLine& slin)
{
Standard_Integer i,l;//,index;
Standard_Integer NbPoints = solrst.NbPoints();
Standard_Real theparam;
IntSurf_Transition TLine,TArc;
Standard_Boolean goon;
gp_Pnt2d pt2d;
gp_Vec2d d2d;
gp_Pnt ptonsurf;
gp_Vec vectg,normale,tgtrst;
Standard_Real paramlin = 0.0;
Standard_Integer nbLin = slin.Length();
for(l=1;l<=nbLin;l++) {
Contap_TheLine& Line=slin.ChangeValue(l);
for (i=1; i<= NbPoints; i++) {
const Contap_ThePathPointOfTheSearch& PStart = solrst.Point(i);
const TheArc& thearc = PStart.Arc();
theparam = PStart.Parameter();
TheArcTool::D1(thearc,theparam,pt2d,d2d);
goon = FindLine(Line,Surf,pt2d,ptonsurf,paramlin,vectg,normale);
Contap_ThePoint PPoint;
if (goon) {
gp_Vec d1u,d1v;
gp_Pnt bidpt;
TheSurfaceTool::D1(Surf,pt2d.X(),pt2d.Y(),bidpt,d1u,d1v);
PPoint.SetValue(ptonsurf,pt2d.X(),pt2d.Y());
if (normale.Magnitude() < RealEpsilon()) {
TLine.SetValue();
TArc.SetValue();
}
else {
// Petit test qui devrait permettre de bien traiter les pointes
// des cones, et les sommets d`une sphere. Il faudrait peut-etre
// rajouter une methode dans SurfProps
if (Abs(d2d.Y()) <= Precision::Confusion()) {
tgtrst = d1v.Crossed(normale);
if(d2d.X() < 0.0)
tgtrst.Reverse();
}
else {
tgtrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
}
IntSurf::MakeTransition(vectg,tgtrst,normale,TLine,TArc);
}
PPoint.SetArc(thearc,theparam, TLine, TArc);
PPoint.SetParameter(paramlin);
if (!PStart.IsNew()) {
PPoint.SetVertex(PStart.Vertex());
}
Line.Add(PPoint);
}
}
}
}
//----------------------------------------------------------------------------------
//-- Orientation des contours Apparents quand ceux-ci sont des lignes ou des cercles
//-- On prend un point de la ligne ou du cercle ---> P
//-- On projete ce point sur la surface P ---> u,v
//-- et on evalue la transition au point u,v
//----------------------------------------------------------------------------------
IntSurf_TypeTrans ComputeTransitionOngpLine
(Contap_TheSurfFunction& SFunc,
const gp_Lin& L)
{
const TheSurface& Surf=SFunc.Surface();
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
gp_Pnt P;
gp_Vec T;
ElCLib::D1(0.0,L,P,T);
Standard_Real u = 0.,v = 0.;
switch (typS) {
case GeomAbs_Cylinder: {
ElSLib::Parameters(TheSurfaceTool::Cylinder(Surf),P,u,v);
break;
}
case GeomAbs_Cone: {
ElSLib::Parameters(TheSurfaceTool::Cone(Surf),P,u,v);
break;
}
case GeomAbs_Sphere: {
ElSLib::Parameters(TheSurfaceTool::Sphere(Surf),P,u,v);
break;
}
default:
break;
}
return(ComputeTransitionOnLine(SFunc,u,v,T));
}
IntSurf_TypeTrans ComputeTransitionOngpCircle
(Contap_TheSurfFunction& SFunc,
const gp_Circ& C)
{
const TheSurface& Surf=SFunc.Surface();
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
gp_Pnt P;
gp_Vec T;
ElCLib::D1(0.0,C,P,T);
Standard_Real u = 0.,v = 0.;
switch (typS) {
case GeomAbs_Cylinder: {
ElSLib::Parameters(TheSurfaceTool::Cylinder(Surf),P,u,v);
break;
}
case GeomAbs_Cone: {
ElSLib::Parameters(TheSurfaceTool::Cone(Surf),P,u,v);
break;
}
case GeomAbs_Sphere: {
ElSLib::Parameters(TheSurfaceTool::Sphere(Surf),P,u,v);
break;
}
default:
break;
}
return(ComputeTransitionOnLine(SFunc,u,v,T));
}
void Contap_ContourGen::PerformAna(const Handle(TheTopolTool)& Domain)
{
done = Standard_False;
slin.Clear();
Standard_Real TolArc = 1.e-5;
Standard_Integer nbCont, nbPointRst, i;
//gp_Circ cirsol;
//gp_Lin linsol;
Contap_ContAna contana;
Contap_TheLine theline;
const TheSurface& Surf = mySFunc.Surface();
Contap_TFunction TypeFunc(mySFunc.FunctionType());
Standard_Boolean PerformSolRst = Standard_True;
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
switch (typS) {
case GeomAbs_Plane:
{
gp_Pln pl(TheSurfaceTool::Plane(Surf));
switch (TypeFunc) {
case Contap_ContourStd:
{
gp_Dir Dirpln(pl.Axis().Direction());
if (Abs(mySFunc.Direction().Dot(Dirpln)) > Precision::Angular()) {
// Aucun point du plan n`est solution, en particulier aucun point
// sur restriction.
PerformSolRst = Standard_False;
}
}
break;
case Contap_ContourPrs:
{
gp_Pnt Eye(mySFunc.Eye());
if (pl.Distance(Eye) > Precision::Confusion()) {
// Aucun point du plan n`est solution, en particulier aucun point
// sur restriction.
PerformSolRst = Standard_False;
}
}
break;
case Contap_DraftStd:
{
gp_Dir Dirpln(pl.Axis().Direction());
Standard_Real Sina = Sin(mySFunc.Angle());
if (Abs(mySFunc.Direction().Dot(Dirpln)+ Sina) > //voir SurfFunction
Precision::Angular()) {
PerformSolRst = Standard_False;
}
}
break;
case Contap_DraftPrs:
default:
{
}
}
}
break;
case GeomAbs_Sphere:
{
switch (TypeFunc) {
case Contap_ContourStd:
{
contana.Perform(TheSurfaceTool::Sphere(Surf),mySFunc.Direction());
}
break;
case Contap_ContourPrs:
{
contana.Perform(TheSurfaceTool::Sphere(Surf),mySFunc.Eye());
}
break;
case Contap_DraftStd:
{
contana.Perform(TheSurfaceTool::Sphere(Surf),
mySFunc.Direction(),mySFunc.Angle());
}
break;
case Contap_DraftPrs:
default:
{
}
}
}
break;
case GeomAbs_Cylinder:
{
switch (TypeFunc) {
case Contap_ContourStd:
{
contana.Perform(TheSurfaceTool::Cylinder(Surf),mySFunc.Direction());
}
break;
case Contap_ContourPrs:
{
contana.Perform(TheSurfaceTool::Cylinder(Surf),mySFunc.Eye());
}
break;
case Contap_DraftStd:
{
contana.Perform(TheSurfaceTool::Cylinder(Surf),
mySFunc.Direction(),mySFunc.Angle());
}
break;
case Contap_DraftPrs:
default:
{
}
}
}
break;
case GeomAbs_Cone:
{
switch (TypeFunc) {
case Contap_ContourStd:
{
contana.Perform(TheSurfaceTool::Cone(Surf),mySFunc.Direction());
}
break;
case Contap_ContourPrs:
{
contana.Perform(TheSurfaceTool::Cone(Surf),mySFunc.Eye());
}
break;
case Contap_DraftStd:
{
contana.Perform(TheSurfaceTool::Cone(Surf),
mySFunc.Direction(),mySFunc.Angle());
}
break;
case Contap_DraftPrs:
default:
{
}
}
default:
break;
}
break;
}
if (typS != GeomAbs_Plane) {
if (!contana.IsDone()) {
return;
}
nbCont = contana.NbContours();
if (contana.NbContours() == 0) {
done = Standard_True;
return;
}
GeomAbs_CurveType typL = contana.TypeContour();
if (typL == GeomAbs_Circle) {
theline.SetValue(contana.Circle());
IntSurf_TypeTrans TransCircle;
TransCircle = ComputeTransitionOngpCircle(mySFunc,contana.Circle());
theline.SetTransitionOnS(TransCircle);
slin.Append(theline);
}
else if (typL == GeomAbs_Line) {
for (i=1; i<=nbCont; i++) {
theline.SetValue(contana.Line(i));
IntSurf_TypeTrans TransLine;
TransLine = ComputeTransitionOngpLine(mySFunc,contana.Line(i));
theline.SetTransitionOnS(TransLine);
slin.Append(theline);
theline.Clear();
}
/*
if (typS == GeomAbs_Cone) {
Standard_Real u,v;
gp_Cone thecone(TheSurfaceTool::Cone(Surf));
ElSLib::Parameters(thecone,thecone.Apex(),u,v);
Contap_ThePoint vtxapex(thecone.Apex(),u,v);
vtxapex.SetInternal();
vtxapex.SetMultiple();
for (i=1; i<=nbCont i++) {
slin.ChangeValue(i).Add(vtxapex);
}
}
*/
}
}
if(PerformSolRst) {
solrst.Perform(myAFunc,Domain,TolArc,TolArc);
if (!solrst.IsDone()) {
return;
}
nbPointRst = solrst.NbPoints();
if (nbPointRst != 0) {
PutPointsOnLine(solrst,Surf,slin);
}
if (solrst.NbSegments() !=0) {
ProcessSegments(solrst,slin,TolArc,mySFunc,Domain);
}
//-- lbr
//Standard_Boolean oneremov;
Standard_Integer nblinto = slin.Length();
TColStd_SequenceOfInteger SeqToDestroy;
//-- cout<<" Construct Contour_3 nblin = "<<nblinto<<endl;
for(i=1; i<= nblinto ; i++) {
//-- cout<<" nbvtx : "<<slin.Value(i).NbVertex()<<endl;
//--if(slin.Value(i).NbVertex() > 1) {
if(slin.Value(i).TypeContour() != Contap_Restriction) {
LineConstructor(slin,Domain,slin.ChangeValue(i),Surf);
SeqToDestroy.Append(i);
}
//-- }
}
for(i=SeqToDestroy.Length(); i>=1; i--) {
slin.Remove(SeqToDestroy.Value(i));
}
}
done = Standard_True;
}

58
src/Contap/Contap_HContToolGen.cdl → src/Contap/Contap_HContTool.cdl
View File

@ -14,46 +14,44 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class HContToolGen from Contap ( class HContTool from Contap
TheHVertex as any;
TheHCurve2d as any;
TheHSurface as any;
TheHCurve2dTool as any;
TheHSurfaceTool as any)
---Purpose: Tool for the intersection between 2 surfaces. ---Purpose: Tool for the intersection between 2 surfaces.
-- Regroupe pour l instant les methodes hors Adaptor3d... -- Regroupe pour l instant les methodes hors Adaptor3d...
uses uses
Pnt2d from gp, Pnt2d from gp,
Pnt from gp Pnt from gp,
HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d
is is
NbSamplesU(myclass; S: HSurface from Adaptor3d; u1,u2: Real from Standard)
NbSamplesU(myclass; S: TheHSurface; u1,u2: Real from Standard)
returns Integer from Standard; returns Integer from Standard;
NbSamplesV(myclass; S: TheHSurface; v1,v2: Real from Standard) NbSamplesV(myclass; S: HSurface from Adaptor3d; v1,v2: Real from Standard)
returns Integer from Standard; returns Integer from Standard;
-- Methodes pour recherche des points interieurs -- Methodes pour recherche des points interieurs
NbSamplePoints(myclass; S: TheHSurface) NbSamplePoints(myclass; S: HSurface from Adaptor3d)
returns Integer from Standard; returns Integer from Standard;
SamplePoint(myclass; S : TheHSurface; SamplePoint(myclass; S : HSurface from Adaptor3d;
Index: Integer from Standard; Index: Integer from Standard;
U,V: out Real from Standard); U,V: out Real from Standard);
-- Methodes sur un arc de restriction -- Methodes sur un arc de restriction
HasBeenSeen(myclass; C: TheHCurve2d) HasBeenSeen(myclass; C: HCurve2d from Adaptor2d)
---Purpose: Returns True if all the intersection point and edges ---Purpose: Returns True if all the intersection point and edges
-- are known on the Arc. -- are known on the Arc.
@ -63,7 +61,7 @@ is
returns Boolean from Standard; returns Boolean from Standard;
NbSamplesOnArc(myclass; A: TheHCurve2d) NbSamplesOnArc(myclass; A: HCurve2d from Adaptor2d)
---Purpose: returns the number of points which is used to make ---Purpose: returns the number of points which is used to make
-- a sample on the arc. this number is a function of -- a sample on the arc. this number is a function of
@ -72,7 +70,7 @@ is
returns Integer from Standard; returns Integer from Standard;
Bounds(myclass; C: TheHCurve2d; Bounds(myclass; C: HCurve2d from Adaptor2d;
Ufirst,Ulast: out Real from Standard); Ufirst,Ulast: out Real from Standard);
---Purpose: Returns the parametric limits on the arc C. ---Purpose: Returns the parametric limits on the arc C.
@ -81,7 +79,7 @@ is
-- or a bounding box for an infinite arc. -- or a bounding box for an infinite arc.
Project(myclass; C: TheHCurve2d; Project(myclass; C: HCurve2d from Adaptor2d;
P: Pnt2d from gp; P: Pnt2d from gp;
Paramproj: out Real from Standard; Paramproj: out Real from Standard;
Ptproj : out Pnt2d from gp) Ptproj : out Pnt2d from gp)
@ -100,7 +98,7 @@ is
-- Methods on a vertex -- Methods on a vertex
Tolerance(myclass; V: TheHVertex; C: TheHCurve2d) Tolerance(myclass; V: HVertex from Adaptor3d; C: HCurve2d from Adaptor2d)
---Purpose: Returns the parametric tolerance used to consider ---Purpose: Returns the parametric tolerance used to consider
-- that the vertex and another point meet, i-e -- that the vertex and another point meet, i-e
@ -110,7 +108,7 @@ is
returns Real from Standard; returns Real from Standard;
Parameter(myclass; V: TheHVertex; C: TheHCurve2d) Parameter(myclass; V: HVertex from Adaptor3d; C: HCurve2d from Adaptor2d)
---Purpose: Returns the parameter of the vertex V on the arc A. ---Purpose: Returns the parameter of the vertex V on the arc A.
@ -119,14 +117,14 @@ is
-- The following methods are used when HasBeenSeen returns Standard_True -- The following methods are used when HasBeenSeen returns Standard_True
NbPoints(myclass; C: TheHCurve2d) NbPoints(myclass; C: HCurve2d from Adaptor2d)
---Purpose: Returns the number of intersection points on the arc A. ---Purpose: Returns the number of intersection points on the arc A.
returns Integer from Standard; returns Integer from Standard;
Value(myclass; C: TheHCurve2d; Index: Integer from Standard; Value(myclass; C: HCurve2d from Adaptor2d; Index: Integer from Standard;
Pt: out Pnt from gp; Tol: out Real from Standard; Pt: out Pnt from gp; Tol: out Real from Standard;
U: out Real from Standard); U: out Real from Standard);
@ -135,7 +133,7 @@ is
-- point of range Index. -- point of range Index.
IsVertex(myclass; C: TheHCurve2d; IsVertex(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard) Index: Integer from Standard)
---Purpose: Returns True if the intersection point of range Index ---Purpose: Returns True if the intersection point of range Index
@ -144,14 +142,14 @@ is
returns Boolean from Standard; returns Boolean from Standard;
Vertex(myclass; C: TheHCurve2d; Index: Integer from Standard; Vertex(myclass; C: HCurve2d from Adaptor2d; Index: Integer from Standard;
V: out TheHVertex); V: out HVertex from Adaptor3d);
---Purpose: When IsVertex returns True, this method returns the ---Purpose: When IsVertex returns True, this method returns the
-- vertex on the arc A. -- vertex on the arc A.
NbSegments(myclass; C: TheHCurve2d) NbSegments(myclass; C: HCurve2d from Adaptor2d)
---Purpose: returns the number of part of A solution of the ---Purpose: returns the number of part of A solution of the
-- of intersection problem. -- of intersection problem.
@ -159,7 +157,7 @@ is
returns Integer from Standard; returns Integer from Standard;
HasFirstPoint(myclass; C: TheHCurve2d; HasFirstPoint(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard; Index: Integer from Standard;
IndFirst: out Integer from Standard) IndFirst: out Integer from Standard)
@ -173,7 +171,7 @@ is
returns Boolean from Standard; returns Boolean from Standard;
HasLastPoint(myclass; C: TheHCurve2d; HasLastPoint(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard; Index: Integer from Standard;
IndLast: out Integer from Standard) IndLast: out Integer from Standard)
@ -187,7 +185,7 @@ is
returns Boolean from Standard; returns Boolean from Standard;
IsAllSolution(myclass; C: TheHCurve2d) IsAllSolution(myclass; C: HCurve2d from Adaptor2d)
---Purpose: Returns True when the whole restriction is solution ---Purpose: Returns True when the whole restriction is solution
-- of the intersection problem. -- of the intersection problem.
@ -195,4 +193,4 @@ is
returns Boolean from Standard; returns Boolean from Standard;
end HContToolGen; end HContTool;

152
src/Contap/Contap_HContToolGen.gxx → src/Contap/Contap_HContTool.cxx
View File

@ -14,33 +14,17 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <Contap_HContTool.ixx>
#include <Extrema_EPCOfExtPC2d.hxx> #include <Extrema_EPCOfExtPC2d.hxx>
#include <Extrema_POnCurv2d.hxx> #include <Extrema_POnCurv2d.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Standard_OutOfRange.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
static Standard_Real uinf,vinf,usup,vsup; static Standard_Real uinf,vinf,usup,vsup;
#include TheHSurface_hxx Standard_Integer Contap_HContTool::NbSamplesV
#include TheHCurve2d_hxx (const Handle(Adaptor3d_HSurface)& S,
#include TheHVertex_hxx const Standard_Real ,
const Standard_Real )
Standard_Integer Contap_HContToolGen::NbSamplesV
(const TheHSurface& S,
const Standard_Real ,
const Standard_Real )
{ {
Standard_Integer nbs; Standard_Integer nbs;
GeomAbs_SurfaceType typS = S->GetType(); GeomAbs_SurfaceType typS = S->GetType();
@ -61,7 +45,7 @@ Standard_Integer Contap_HContToolGen::NbSamplesV
nbs = S->NbVKnots(); nbs = S->NbVKnots();
nbs*= S->VDegree(); nbs*= S->VDegree();
if(nbs < 2) nbs=2; if(nbs < 2) nbs=2;
} }
break; break;
case GeomAbs_Cylinder: case GeomAbs_Cylinder:
@ -74,7 +58,7 @@ Standard_Integer Contap_HContToolGen::NbSamplesV
nbs = 15; nbs = 15;
} }
break; break;
default: default:
{ {
nbs = 10; nbs = 10;
@ -84,10 +68,10 @@ Standard_Integer Contap_HContToolGen::NbSamplesV
return(nbs); return(nbs);
} }
Standard_Integer Contap_HContToolGen::NbSamplesU Standard_Integer Contap_HContTool::NbSamplesU
(const TheHSurface& S, (const Handle(Adaptor3d_HSurface)& S,
const Standard_Real , const Standard_Real ,
const Standard_Real ) const Standard_Real )
{ {
Standard_Integer nbs; Standard_Integer nbs;
GeomAbs_SurfaceType typS = S->GetType(); GeomAbs_SurfaceType typS = S->GetType();
@ -108,7 +92,7 @@ Standard_Integer Contap_HContToolGen::NbSamplesU
nbs = S->NbUKnots(); nbs = S->NbUKnots();
nbs*= S->UDegree(); nbs*= S->UDegree();
if(nbs < 2) nbs=2; if(nbs < 2) nbs=2;
} }
break; break;
case GeomAbs_Torus: case GeomAbs_Torus:
@ -125,7 +109,7 @@ Standard_Integer Contap_HContToolGen::NbSamplesU
nbs = 10; nbs = 10;
} }
break; break;
default: default:
{ {
nbs = 10; nbs = 10;
@ -135,8 +119,8 @@ Standard_Integer Contap_HContToolGen::NbSamplesU
return(nbs); return(nbs);
} }
Standard_Integer Contap_HContToolGen::NbSamplePoints Standard_Integer Contap_HContTool::NbSamplePoints
(const TheHSurface& S) (const Handle(Adaptor3d_HSurface)& S)
{ {
uinf = S->FirstUParameter(); uinf = S->FirstUParameter();
usup = S->LastUParameter(); usup = S->LastUParameter();
@ -147,8 +131,8 @@ Standard_Integer Contap_HContToolGen::NbSamplePoints
Standard_Real temp = uinf; Standard_Real temp = uinf;
uinf = usup; uinf = usup;
usup = temp; usup = temp;
} }
if (vsup < vinf) { if (vsup < vinf) {
Standard_Real temp = vinf; Standard_Real temp = vinf;
vinf = vsup; vinf = vsup;
vsup = temp; vsup = temp;
@ -163,7 +147,7 @@ Standard_Integer Contap_HContToolGen::NbSamplePoints
else if (usup == RealLast()) { else if (usup == RealLast()) {
usup = uinf + 2.e5; usup = uinf + 2.e5;
} }
if (vinf == RealFirst() && vsup == RealLast()) { if (vinf == RealFirst() && vsup == RealLast()) {
vinf = -1.e5; vinf = -1.e5;
vsup = 1.e5; vsup = 1.e5;
@ -183,10 +167,10 @@ Standard_Integer Contap_HContToolGen::NbSamplePoints
return 5; return 5;
} }
void Contap_HContToolGen::SamplePoint (const TheHSurface& S, void Contap_HContTool::SamplePoint (const Handle(Adaptor3d_HSurface)& S,
const Standard_Integer Index, const Standard_Integer Index,
Standard_Real& U, Standard_Real& U,
Standard_Real& V ) Standard_Real& V )
{ {
if(S->GetType() == GeomAbs_BSplineSurface) { if(S->GetType() == GeomAbs_BSplineSurface) {
Standard_Integer nbIntU = NbSamplesU(S,uinf,usup)/3; Standard_Integer nbIntU = NbSamplesU(S,uinf,usup)/3;
@ -194,17 +178,17 @@ void Contap_HContToolGen::SamplePoint (const TheHSurface& S,
if(nbIntU * nbIntV >5) { if(nbIntU * nbIntV >5) {
Standard_Integer indU = (Index-1)/nbIntU; //---- 0 --> nbIntV Standard_Integer indU = (Index-1)/nbIntU; //---- 0 --> nbIntV
Standard_Integer indV = (Index-1) - indU*nbIntU; //---- 0 --> nbIntU Standard_Integer indV = (Index-1) - indU*nbIntU; //---- 0 --> nbIntU
U = uinf + ((usup-uinf)/((Standard_Real)(nbIntU+1)))*(Standard_Real)(indU+1); U = uinf + ((usup-uinf)/((Standard_Real)(nbIntU+1)))*(Standard_Real)(indU+1);
V = vinf + ((vsup-vinf)/((Standard_Real)(nbIntV+2)))*(Standard_Real)(indV+1); V = vinf + ((vsup-vinf)/((Standard_Real)(nbIntV+2)))*(Standard_Real)(indV+1);
//-- cout<<"Index :"<<Index<<" uinf:"<<uinf<<" usup:"<<usup<<" vinf:"<<vinf<<" vsup:"<<vsup<<" "; //-- cout<<"Index :"<<Index<<" uinf:"<<uinf<<" usup:"<<usup<<" vinf:"<<vinf<<" vsup:"<<vsup<<" ";
//-- cout<<" ("<<indU<<"/"<<nbIntU<<" ->U:"<<U<<" "; //-- cout<<" ("<<indU<<"/"<<nbIntU<<" ->U:"<<U<<" ";
//-- cout<<" ("<<indV<<"/"<<nbIntV<<" ->V:"<<V<<endl; //-- cout<<" ("<<indV<<"/"<<nbIntV<<" ->V:"<<V<<endl;
return; return;
} }
} }
switch (Index) { switch (Index) {
case 1: case 1:
U = 0.75*uinf + 0.25*usup; //0.25; U = 0.75*uinf + 0.25*usup; //0.25;
@ -229,8 +213,8 @@ void Contap_HContToolGen::SamplePoint (const TheHSurface& S,
} }
Standard_Integer Contap_HContToolGen::NbSamplesOnArc Standard_Integer Contap_HContTool::NbSamplesOnArc
(const TheHCurve2d& A) { (const Handle(Adaptor2d_HCurve2d)& A) {
GeomAbs_CurveType CurveType = A->GetType(); GeomAbs_CurveType CurveType = A->GetType();
@ -252,7 +236,7 @@ Standard_Integer Contap_HContToolGen::NbSamplesOnArc
//-- Handle_Geom2d_BSplineCurve& BSC=A->BSpline(); //-- Handle_Geom2d_BSplineCurve& BSC=A->BSpline();
nbsOnC = 2 + A->NbKnots() * A->Degree(); nbsOnC = 2 + A->NbKnots() * A->Degree();
break; break;
} }
default: default:
nbsOnC = 10; nbsOnC = 10;
} }
@ -260,19 +244,19 @@ Standard_Integer Contap_HContToolGen::NbSamplesOnArc
} }
void Contap_HContToolGen::Bounds(const TheHCurve2d& A, void Contap_HContTool::Bounds(const Handle(Adaptor2d_HCurve2d)& A,
Standard_Real& Ufirst, Standard_Real& Ufirst,
Standard_Real& Ulast) Standard_Real& Ulast)
{ {
Ufirst = A->FirstParameter(); Ufirst = A->FirstParameter();
Ulast = A->LastParameter(); Ulast = A->LastParameter();
} }
Standard_Boolean Contap_HContToolGen::Project (const TheHCurve2d& C, Standard_Boolean Contap_HContTool::Project (const Handle(Adaptor2d_HCurve2d)& C,
const gp_Pnt2d& P, const gp_Pnt2d& P,
Standard_Real& Paramproj, Standard_Real& Paramproj,
gp_Pnt2d& Ptproj) gp_Pnt2d& Ptproj)
{ {
@ -303,80 +287,80 @@ Standard_Boolean Contap_HContToolGen::Project (const TheHCurve2d& C,
} }
Standard_Real Contap_HContToolGen::Tolerance (const TheHVertex& V, Standard_Real Contap_HContTool::Tolerance (const Handle(Adaptor3d_HVertex)& V,
const TheHCurve2d& C) const Handle(Adaptor2d_HCurve2d)& C)
{ {
// return BRepAdaptor2d_Curve2dTool::Resolution(C,BRep_Tool::Tolerance(V)); // return BRepAdaptor2d_Curve2dTool::Resolution(C,BRep_Tool::Tolerance(V));
return V->Resolution(C); return V->Resolution(C);
} }
Standard_Real Contap_HContToolGen::Parameter (const TheHVertex& V, Standard_Real Contap_HContTool::Parameter (const Handle(Adaptor3d_HVertex)& V,
const TheHCurve2d& C) const Handle(Adaptor2d_HCurve2d)& C)
{ {
// return BRep_Tool::Parameter(V,C.Edge()); // return BRep_Tool::Parameter(V,C.Edge());
return V->Parameter(C); return V->Parameter(C);
} }
Standard_Boolean Contap_HContToolGen::HasBeenSeen Standard_Boolean Contap_HContTool::HasBeenSeen
(const TheHCurve2d&) (const Handle(Adaptor2d_HCurve2d)&)
{ {
return Standard_False; return Standard_False;
} }
Standard_Integer Contap_HContToolGen::NbPoints(const TheHCurve2d&) Standard_Integer Contap_HContTool::NbPoints(const Handle(Adaptor2d_HCurve2d)&)
{ {
return 0; return 0;
} }
void Contap_HContToolGen::Value(const TheHCurve2d&, void Contap_HContTool::Value(const Handle(Adaptor2d_HCurve2d)&,
const Standard_Integer, const Standard_Integer,
gp_Pnt&, gp_Pnt&,
Standard_Real&, Standard_Real&,
Standard_Real&) Standard_Real&)
{ {
Standard_OutOfRange::Raise(); Standard_OutOfRange::Raise();
} }
Standard_Boolean Contap_HContToolGen::IsVertex(const TheHCurve2d&, Standard_Boolean Contap_HContTool::IsVertex(const Handle(Adaptor2d_HCurve2d)&,
const Standard_Integer) const Standard_Integer)
{ {
return Standard_False; return Standard_False;
} }
void Contap_HContToolGen::Vertex(const TheHCurve2d&, void Contap_HContTool::Vertex(const Handle(Adaptor2d_HCurve2d)&,
const Standard_Integer, const Standard_Integer,
TheHVertex&) Handle(Adaptor3d_HVertex)&)
{ {
Standard_OutOfRange::Raise(); Standard_OutOfRange::Raise();
} }
Standard_Integer Contap_HContToolGen::NbSegments(const TheHCurve2d&) Standard_Integer Contap_HContTool::NbSegments(const Handle(Adaptor2d_HCurve2d)&)
{ {
return 0; return 0;
} }
Standard_Boolean Contap_HContToolGen::HasFirstPoint Standard_Boolean Contap_HContTool::HasFirstPoint
(const TheHCurve2d&, (const Handle(Adaptor2d_HCurve2d)&,
const Standard_Integer, const Standard_Integer,
Standard_Integer&) Standard_Integer&)
{ {
Standard_OutOfRange::Raise(); Standard_OutOfRange::Raise();
return Standard_False; return Standard_False;
} }
Standard_Boolean Contap_HContToolGen::HasLastPoint Standard_Boolean Contap_HContTool::HasLastPoint
(const TheHCurve2d&, (const Handle(Adaptor2d_HCurve2d)&,
const Standard_Integer, const Standard_Integer,
Standard_Integer&) Standard_Integer&)
{ {
Standard_OutOfRange::Raise(); Standard_OutOfRange::Raise();
return Standard_False; return Standard_False;
} }
Standard_Boolean Contap_HContToolGen::IsAllSolution Standard_Boolean Contap_HContTool::IsAllSolution
(const TheHCurve2d&) (const Handle(Adaptor2d_HCurve2d)&)
{ {
return Standard_False; return Standard_False;

78
src/Contap/Contap_HCurve2dToolGen.cdl → src/Contap/Contap_HCurve2dTool.cdl
View File

@ -14,22 +14,22 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class HCurve2dToolGen from Contap ( class HCurve2dTool from Contap
CurveGen as any)
uses uses
Array1OfReal from TColStd, Array1OfReal from TColStd,
Shape from GeomAbs, Shape from GeomAbs,
CurveType from GeomAbs, CurveType from GeomAbs,
Vec2d from gp, Vec2d from gp,
Pnt2d from gp, Pnt2d from gp,
Circ2d from gp, Circ2d from gp,
Elips2d from gp, Elips2d from gp,
Hypr2d from gp, Hypr2d from gp,
Parab2d from gp, Parab2d from gp,
Lin2d from gp, Lin2d from gp,
BezierCurve from Geom2d, BezierCurve from Geom2d,
BSplineCurve from Geom2d BSplineCurve from Geom2d,
HCurve2d from Adaptor2d
raises raises
@ -43,12 +43,12 @@ is
-- Global methods - Apply to the whole curve. -- Global methods - Apply to the whole curve.
-- --
FirstParameter(myclass; C: CurveGen) returns Real FirstParameter(myclass; C: HCurve2d from Adaptor2d) returns Real
---C++: inline ---C++: inline
; ;
LastParameter(myclass; C: CurveGen) returns Real LastParameter(myclass; C: HCurve2d from Adaptor2d) returns Real
---C++: inline ---C++: inline
; ;
@ -72,18 +72,18 @@ is
-- use the method Trim(). -- use the method Trim().
Continuity(myclass; C: CurveGen) returns Shape from GeomAbs Continuity(myclass; C: HCurve2d from Adaptor2d) returns Shape from GeomAbs
---Purpose: ---Purpose:
---C++: inline ---C++: inline
; ;
NbIntervals(myclass; C: CurveGen; S : Shape from GeomAbs) returns Integer NbIntervals(myclass; C: HCurve2d from Adaptor2d; S : Shape from GeomAbs) returns Integer
---Purpose: Returns the number of intervals for continuity ---Purpose: Returns the number of intervals for continuity
-- <S>. May be one if Continuity(myclass) >= <S> -- <S>. May be one if Continuity(myclass) >= <S>
---C++: inline ---C++: inline
; ;
Intervals(myclass; C: CurveGen; T : in out Array1OfReal from TColStd; Intervals(myclass; C: HCurve2d from Adaptor2d; T : in out Array1OfReal from TColStd;
S : Shape from GeomAbs) S : Shape from GeomAbs)
---Purpose: Stores in <T> the parameters bounding the intervals ---Purpose: Stores in <T> the parameters bounding the intervals
-- of continuity <S>. -- of continuity <S>.
@ -95,31 +95,31 @@ is
---C++: inline ---C++: inline
; ;
IsClosed(myclass; C: CurveGen) returns Boolean IsClosed(myclass; C: HCurve2d from Adaptor2d) returns Boolean
---C++: inline ---C++: inline
; ;
IsPeriodic(myclass; C: CurveGen) returns Boolean IsPeriodic(myclass; C: HCurve2d from Adaptor2d) returns Boolean
---C++: inline ---C++: inline
; ;
Period(myclass; C: CurveGen) returns Real Period(myclass; C: HCurve2d from Adaptor2d) returns Real
raises raises
DomainError from Standard -- if the curve is not periodic DomainError from Standard -- if the curve is not periodic
---C++: inline ---C++: inline
; ;
Value(myclass; C: CurveGen; U : Real) returns Pnt2d from gp Value(myclass; C: HCurve2d from Adaptor2d; U : Real) returns Pnt2d from gp
--- Purpose : Computes the point of parameter U on the curve. --- Purpose : Computes the point of parameter U on the curve.
---C++: inline ---C++: inline
; ;
D0 (myclass; C: CurveGen; U : Real; P : out Pnt2d from gp) D0 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp)
--- Purpose : Computes the point of parameter U on the curve. --- Purpose : Computes the point of parameter U on the curve.
---C++: inline ---C++: inline
; ;
D1 (myclass; C: CurveGen; U : Real; P : out Pnt2d from gp ; V : out Vec2d from gp) D1 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp ; V : out Vec2d from gp)
--- Purpose : Computes the point of parameter U on the curve with its --- Purpose : Computes the point of parameter U on the curve with its
-- first derivative. -- first derivative.
raises raises
@ -129,7 +129,7 @@ is
---C++: inline ---C++: inline
; ;
D2 (myclass; C: CurveGen; U : Real; P : out Pnt2d from gp; V1, V2 : out Vec2d from gp) D2 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp; V1, V2 : out Vec2d from gp)
--- Purpose : --- Purpose :
-- Returns the point P of parameter U, the first and second -- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2. -- derivatives V1 and V2.
@ -140,7 +140,7 @@ is
---C++: inline ---C++: inline
; ;
D3 (myclass; C: CurveGen; U : Real; P : out Pnt2d from gp; V1, V2, V3 : out Vec2d from gp) D3 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp; V1, V2, V3 : out Vec2d from gp)
--- Purpose : --- Purpose :
-- Returns the point P of parameter U, the first, the second -- Returns the point P of parameter U, the first, the second
-- and the third derivative. -- and the third derivative.
@ -151,7 +151,7 @@ is
---C++: inline ---C++: inline
; ;
DN (myclass; C: CurveGen; U : Real; N : Integer) returns Vec2d from gp DN (myclass; C: HCurve2d from Adaptor2d; U : Real; N : Integer) returns Vec2d from gp
--- Purpose : --- Purpose :
-- The returned vector gives the value of the derivative for the -- The returned vector gives the value of the derivative for the
-- order of derivation N. -- order of derivation N.
@ -164,13 +164,13 @@ is
---C++: inline ---C++: inline
; ;
Resolution(myclass; C: CurveGen; R3d : Real) returns Real Resolution(myclass; C: HCurve2d from Adaptor2d; R3d : Real) returns Real
---Purpose : Returns the parametric resolution corresponding ---Purpose : Returns the parametric resolution corresponding
-- to the real space resolution <R3d>. -- to the real space resolution <R3d>.
---C++: inline ---C++: inline
; ;
GetType(myclass; C: CurveGen) returns CurveType from GeomAbs GetType(myclass; C: HCurve2d from Adaptor2d) returns CurveType from GeomAbs
---Purpose: Returns the type of the curve in the current ---Purpose: Returns the type of the curve in the current
-- interval : Line, Circle, Ellipse, Hyperbola, -- interval : Line, Circle, Ellipse, Hyperbola,
-- Parabola, BezierCurve, BSplineCurve, OtherCurve. -- Parabola, BezierCurve, BSplineCurve, OtherCurve.
@ -182,43 +182,43 @@ is
-- the corresponding type. -- the corresponding type.
-- --
Line(myclass; C: CurveGen) returns Lin2d from gp Line(myclass; C: HCurve2d from Adaptor2d) returns Lin2d from gp
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
Circle(myclass; C: CurveGen) returns Circ2d from gp Circle(myclass; C: HCurve2d from Adaptor2d) returns Circ2d from gp
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
Ellipse(myclass; C: CurveGen) returns Elips2d from gp Ellipse(myclass; C: HCurve2d from Adaptor2d) returns Elips2d from gp
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
Hyperbola(myclass; C: CurveGen) returns Hypr2d from gp Hyperbola(myclass; C: HCurve2d from Adaptor2d) returns Hypr2d from gp
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
Parabola(myclass; C: CurveGen) returns Parab2d from gp Parabola(myclass; C: HCurve2d from Adaptor2d) returns Parab2d from gp
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
Bezier(myclass; C: CurveGen) returns BezierCurve from Geom2d Bezier(myclass; C: HCurve2d from Adaptor2d) returns BezierCurve from Geom2d
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
; ;
BSpline(myclass; C: CurveGen) returns BSplineCurve from Geom2d BSpline(myclass; C: HCurve2d from Adaptor2d) returns BSplineCurve from Geom2d
raises raises
NoSuchObject from Standard NoSuchObject from Standard
---C++: inline ---C++: inline
@ -228,7 +228,7 @@ is
NbSamples(myclass; C: CurveGen; U0,U1: Real from Standard) NbSamples(myclass; C: HCurve2d from Adaptor2d; U0,U1: Real from Standard)
returns Integer from Standard; returns Integer from Standard;
end HCurve2dToolGen; end HCurve2dTool;

44
src/Contap/Contap_HCurve2dToolGen.gxx → src/Contap/Contap_HCurve2dTool.cxx
View File

@ -14,37 +14,31 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include CurveGen_hxx #include <Contap_HCurve2dTool.ixx>
#include <GeomAbs_CurveType.hxx>
#include <GeomAbs_Shape.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <TColStd_Array1OfReal.hxx>
//============================================================ //============================================================
Standard_Integer Contap_HCurve2dToolGen::NbSamples (const CurveGen& C, Standard_Integer Contap_HCurve2dTool::NbSamples (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U0, const Standard_Real U0,
const Standard_Real U1) const Standard_Real U1)
{ {
Standard_Real nbs = 10.0; Standard_Real nbs = 10.0;
switch (C->GetType()) switch (C->GetType())
{ {
case GeomAbs_Line: case GeomAbs_Line:
nbs = 2.; nbs = 2.;
break; break;
case GeomAbs_BezierCurve: case GeomAbs_BezierCurve:
nbs = 3. + C->NbPoles(); nbs = 3. + C->NbPoles();
break; break;
case GeomAbs_BSplineCurve: case GeomAbs_BSplineCurve:
nbs = C->NbKnots(); nbs = C->NbKnots();
nbs*= C->Degree(); nbs*= C->Degree();
nbs*= C->LastParameter()- C->FirstParameter(); nbs*= C->LastParameter()- C->FirstParameter();
nbs/= U1-U0; nbs/= U1-U0;
if(nbs < 2.0) nbs = 2.; if(nbs < 2.0) nbs = 2.;
break; break;
default: default:
break; break;
} }
if (nbs>50.) if (nbs>50.)
nbs = 50.; nbs = 50.;

48
src/Contap/Contap_HCurve2dToolGen.lxx → src/Contap/Contap_HCurve2dTool.lxx
View File

@ -14,7 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include CurveGen_hxx #include <Adaptor2d_HCurve2d.hxx>
#include <GeomAbs_CurveType.hxx> #include <GeomAbs_CurveType.hxx>
#include <GeomAbs_Shape.hxx> #include <GeomAbs_Shape.hxx>
@ -33,59 +33,59 @@
#include <TColStd_Array1OfReal.hxx> #include <TColStd_Array1OfReal.hxx>
//============================================================ //============================================================
inline Standard_Real Contap_HCurve2dToolGen::FirstParameter (const CurveGen& C) { inline Standard_Real Contap_HCurve2dTool::FirstParameter (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->FirstParameter()); return(C->FirstParameter());
} }
//============================================================ //============================================================
inline Standard_Real Contap_HCurve2dToolGen::LastParameter (const CurveGen& C) { inline Standard_Real Contap_HCurve2dTool::LastParameter (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->LastParameter()); return(C->LastParameter());
} }
//============================================================ //============================================================
inline GeomAbs_Shape Contap_HCurve2dToolGen::Continuity (const CurveGen& C) { inline GeomAbs_Shape Contap_HCurve2dTool::Continuity (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Continuity()); return(C->Continuity());
} }
//============================================================ //============================================================
inline Standard_Integer Contap_HCurve2dToolGen::NbIntervals(const CurveGen& C,const GeomAbs_Shape Sh) { inline Standard_Integer Contap_HCurve2dTool::NbIntervals(const Handle(Adaptor2d_HCurve2d)& C,const GeomAbs_Shape Sh) {
return(C->NbIntervals(Sh)); return(C->NbIntervals(Sh));
} }
//============================================================ //============================================================
inline void Contap_HCurve2dToolGen::Intervals(const CurveGen& C, inline void Contap_HCurve2dTool::Intervals(const Handle(Adaptor2d_HCurve2d)& C,
TColStd_Array1OfReal& Tab, TColStd_Array1OfReal& Tab,
const GeomAbs_Shape Sh) { const GeomAbs_Shape Sh) {
C->Intervals(Tab,Sh); C->Intervals(Tab,Sh);
} }
//============================================================ //============================================================
inline Standard_Boolean Contap_HCurve2dToolGen::IsClosed(const CurveGen& C) { inline Standard_Boolean Contap_HCurve2dTool::IsClosed(const Handle(Adaptor2d_HCurve2d)& C) {
return(C->IsClosed()); return(C->IsClosed());
} }
//============================================================ //============================================================
inline Standard_Boolean Contap_HCurve2dToolGen::IsPeriodic(const CurveGen& C) { inline Standard_Boolean Contap_HCurve2dTool::IsPeriodic(const Handle(Adaptor2d_HCurve2d)& C) {
return(C->IsPeriodic()); return(C->IsPeriodic());
} }
//============================================================ //============================================================
inline Standard_Real Contap_HCurve2dToolGen::Period(const CurveGen& C) { inline Standard_Real Contap_HCurve2dTool::Period(const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Period()); return(C->Period());
} }
//============================================================ //============================================================
inline gp_Pnt2d Contap_HCurve2dToolGen::Value (const CurveGen& C, inline gp_Pnt2d Contap_HCurve2dTool::Value (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U) { const Standard_Real U) {
return(C->Value(U)); return(C->Value(U));
} }
//============================================================ //============================================================
inline void Contap_HCurve2dToolGen::D0(const CurveGen& C, inline void Contap_HCurve2dTool::D0(const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U, const Standard_Real U,
gp_Pnt2d& P) { gp_Pnt2d& P) {
C->D0(U,P); C->D0(U,P);
} }
//============================================================ //============================================================
inline void Contap_HCurve2dToolGen::D1 (const CurveGen& C, inline void Contap_HCurve2dTool::D1 (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U, const Standard_Real U,
gp_Pnt2d& P, gp_Pnt2d& P,
gp_Vec2d& T) { gp_Vec2d& T) {
C->D1(U,P,T); C->D1(U,P,T);
} }
//============================================================ //============================================================
inline void Contap_HCurve2dToolGen::D2 (const CurveGen& C, inline void Contap_HCurve2dTool::D2 (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U, const Standard_Real U,
gp_Pnt2d& P, gp_Pnt2d& P,
gp_Vec2d& T, gp_Vec2d& T,
@ -94,7 +94,7 @@ inline void Contap_HCurve2dToolGen::D2 (const CurveGen& C,
C->D2(U,P,T,N); C->D2(U,P,T,N);
} }
//============================================================ //============================================================
inline void Contap_HCurve2dToolGen::D3 (const CurveGen& C, inline void Contap_HCurve2dTool::D3 (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U, const Standard_Real U,
gp_Pnt2d& P, gp_Pnt2d& P,
gp_Vec2d& V1, gp_Vec2d& V1,
@ -104,47 +104,47 @@ inline void Contap_HCurve2dToolGen::D3 (const CurveGen& C,
C->D3(U,P,V1,V2,V3); C->D3(U,P,V1,V2,V3);
} }
//============================================================ //============================================================
inline gp_Vec2d Contap_HCurve2dToolGen::DN (const CurveGen& C, inline gp_Vec2d Contap_HCurve2dTool::DN (const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real U, const Standard_Real U,
const Standard_Integer N) { const Standard_Integer N) {
return(C->DN(U,N)); return(C->DN(U,N));
} }
//============================================================ //============================================================
inline Standard_Real Contap_HCurve2dToolGen::Resolution(const CurveGen& C, inline Standard_Real Contap_HCurve2dTool::Resolution(const Handle(Adaptor2d_HCurve2d)& C,
const Standard_Real R3d) { const Standard_Real R3d) {
return(C->Resolution(R3d)); return(C->Resolution(R3d));
} }
//============================================================ //============================================================
inline GeomAbs_CurveType Contap_HCurve2dToolGen::GetType(const CurveGen& C) { inline GeomAbs_CurveType Contap_HCurve2dTool::GetType(const Handle(Adaptor2d_HCurve2d)& C) {
return(C->GetType()); return(C->GetType());
} }
//============================================================ //============================================================
inline gp_Lin2d Contap_HCurve2dToolGen::Line (const CurveGen& C) { inline gp_Lin2d Contap_HCurve2dTool::Line (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Line()); return(C->Line());
} }
//============================================================ //============================================================
inline gp_Circ2d Contap_HCurve2dToolGen::Circle (const CurveGen& C) { inline gp_Circ2d Contap_HCurve2dTool::Circle (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Circle()); return(C->Circle());
} }
//============================================================ //============================================================
inline gp_Elips2d Contap_HCurve2dToolGen::Ellipse (const CurveGen& C) { inline gp_Elips2d Contap_HCurve2dTool::Ellipse (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Ellipse()); return(C->Ellipse());
} }
//============================================================ //============================================================
inline gp_Parab2d Contap_HCurve2dToolGen::Parabola (const CurveGen& C) { inline gp_Parab2d Contap_HCurve2dTool::Parabola (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Parabola()); return(C->Parabola());
} }
//============================================================ //============================================================
inline gp_Hypr2d Contap_HCurve2dToolGen::Hyperbola (const CurveGen& C) { inline gp_Hypr2d Contap_HCurve2dTool::Hyperbola (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Hyperbola()); return(C->Hyperbola());
} }
//============================================================ //============================================================
inline Handle(Geom2d_BezierCurve) Contap_HCurve2dToolGen::Bezier (const CurveGen& C) { inline Handle(Geom2d_BezierCurve) Contap_HCurve2dTool::Bezier (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->Bezier()); return(C->Bezier());
} }
//============================================================ //============================================================
inline Handle(Geom2d_BSplineCurve) Contap_HCurve2dToolGen::BSpline (const CurveGen& C) { inline Handle(Geom2d_BSplineCurve) Contap_HCurve2dTool::BSpline (const Handle(Adaptor2d_HCurve2d)& C) {
return(C->BSpline()); return(C->BSpline());
} }
//============================================================ //============================================================

25
src/Contap/Contap_Line.cdl
View File

@ -14,12 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class Line from Contap class Line from Contap
(TheVertex as any;
TheArc as any;
ThePoint as any; --as Point from Contap(TheVertex,TheArc)
TheHSequenceOfPoint as Transient) --as HSequence from TCollection
-- (ThePoint)
---Purpose: ---Purpose:
@ -30,7 +25,11 @@ uses Pnt from gp,
Lin from gp, Lin from gp,
Circ from gp, Circ from gp,
Dir from gp, Dir from gp,
IType from Contap -- duplique IntPatch_IType. Mettre ds IntSurf IType from Contap, -- duplique IntPatch_IType. Mettre ds IntSurf
HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
Point from Contap,
TheHSequenceOfPoint from Contap
raises DomainError from Standard, raises DomainError from Standard,
OutOfRange from Standard OutOfRange from Standard
@ -76,12 +75,12 @@ is
is static; is static;
SetValue(me: in out; A: TheArc) SetValue(me: in out; A: HCurve2d from Adaptor2d)
is static; is static;
Add(me: in out; P: ThePoint) Add(me: in out; P: Point from Contap)
is static; is static;
@ -96,7 +95,7 @@ is
Vertex(me; Index: Integer from Standard) Vertex(me; Index: Integer from Standard)
returns ThePoint returns Point from Contap
---C++: return & ---C++: return &
---C++: inline ---C++: inline
@ -171,7 +170,7 @@ is
Arc(me) Arc(me)
returns any TheArc returns any HCurve2d from Adaptor2d
---C++: return const& ---C++: return const&
raises DomainError from Standard raises DomainError from Standard
@ -203,8 +202,8 @@ fields
Trans : TypeTrans from IntSurf; Trans : TypeTrans from IntSurf;
curv : LineOn2S from IntSurf; curv : LineOn2S from IntSurf;
svtx : TheHSequenceOfPoint; svtx : TheHSequenceOfPoint from Contap;
thearc : TheArc; thearc : HCurve2d from Adaptor2d;
typL : IType from Contap; typL : IType from Contap;
pt : Pnt from gp; pt : Pnt from gp;
dir1 : Dir from gp; dir1 : Dir from gp;

22
src/Contap/Contap_Line.gxx → src/Contap/Contap_Line.cxx
View File

@ -14,16 +14,18 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <Contap_Line.ixx>
Contap_Line::Contap_Line () { Contap_Line::Contap_Line () {
svtx = new TheHSequenceOfPoint (); svtx = new Contap_TheHSequenceOfPoint ();
Trans = IntSurf_Undecided; Trans = IntSurf_Undecided;
} }
void Contap_Line::ResetSeqOfVertex() { void Contap_Line::ResetSeqOfVertex() {
svtx = new TheHSequenceOfPoint (); svtx = new Contap_TheHSequenceOfPoint ();
} }
void Contap_Line::Add(const ThePoint& P) { void Contap_Line::Add(const Contap_Point& P) {
Standard_Integer n = svtx->Length(); Standard_Integer n = svtx->Length();
if(n==0) { if(n==0) {
svtx->Append(P); svtx->Append(P);
@ -35,10 +37,10 @@ void Contap_Line::Add(const ThePoint& P) {
} }
else { else {
for(Standard_Integer i=n-1;i>0;i--) { for(Standard_Integer i=n-1;i>0;i--) {
if(prm> svtx->Value(i).ParameterOnLine()) { if(prm> svtx->Value(i).ParameterOnLine()) {
svtx->InsertBefore(i+1,P); svtx->InsertBefore(i+1,P);
return; return;
} }
} }
svtx->Prepend(P); svtx->Prepend(P);
} }
@ -48,7 +50,7 @@ void Contap_Line::Add(const ThePoint& P) {
void Contap_Line::Clear () { void Contap_Line::Clear () {
if(!curv.IsNull()) if(!curv.IsNull())
curv->Clear(); curv->Clear();
svtx = new TheHSequenceOfPoint (); svtx = new Contap_TheHSequenceOfPoint ();
typL = Contap_Walking; typL = Contap_Walking;
} }
@ -68,7 +70,7 @@ void Contap_Line::SetValue(const gp_Circ& C)
typL = Contap_Circle; typL = Contap_Circle;
} }
void Contap_Line::SetValue(const TheArc& A) void Contap_Line::SetValue(const Handle(Adaptor2d_HCurve2d)& A)
{ {
thearc = A; thearc = A;
typL = Contap_Restriction; typL = Contap_Restriction;
@ -87,7 +89,7 @@ IntSurf_TypeTrans Contap_Line::TransitionOnS() const {
return(Trans); return(Trans);
} }
const TheArc& Contap_Line::Arc () const const Handle(Adaptor2d_HCurve2d)& Contap_Line::Arc () const
{ {
if (typL != Contap_Restriction) {Standard_DomainError::Raise();} if (typL != Contap_Restriction) {Standard_DomainError::Raise();}
return thearc; return thearc;

5
src/Contap/Contap_Line.lxx
View File

@ -21,7 +21,8 @@
#include <IntSurf_PntOn2S.hxx> #include <IntSurf_PntOn2S.hxx>
#include <IntSurf_LineOn2S.hxx> #include <IntSurf_LineOn2S.hxx>
#include TheHSequenceOfPoint_hxx #include <Contap_Point.hxx>
#include <Contap_TheHSequenceOfPoint.hxx>
inline const Handle(IntSurf_LineOn2S)& Contap_Line::LineOn2S () const inline const Handle(IntSurf_LineOn2S)& Contap_Line::LineOn2S () const
{ {
@ -38,7 +39,7 @@ inline Standard_Integer Contap_Line::NbVertex () const
return svtx->Length(); return svtx->Length();
} }
inline ThePoint& Contap_Line::Vertex (const Standard_Integer Index) const inline Contap_Point& Contap_Line::Vertex (const Standard_Integer Index) const
{ {
return svtx->ChangeSequence()(Index); return svtx->ChangeSequence()(Index);
} }

20
src/Contap/Contap_Point.cdl
View File

@ -14,9 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class Point from Contap class Point from Contap
(TheVertex as any;
TheArc as any)
---Purpose: Definition of a vertex on the contour line. ---Purpose: Definition of a vertex on the contour line.
@ -28,7 +26,9 @@ generic class Point from Contap
uses Pnt from gp, uses Pnt from gp,
Transition from IntSurf Transition from IntSurf,
HVertex from Adaptor3d,
HCurve2d from Adaptor2d
raises DomainError from Standard raises DomainError from Standard
@ -68,7 +68,7 @@ is
is static; is static;
SetVertex(me: in out; V: TheVertex) SetVertex(me: in out; V: HVertex from Adaptor3d)
---Purpose: Sets the values of a point which is a vertex on ---Purpose: Sets the values of a point which is a vertex on
-- the initial facet of restriction of one -- the initial facet of restriction of one
@ -79,7 +79,7 @@ is
is static; is static;
SetArc(me: in out; A: TheArc; Param: Real from Standard; SetArc(me: in out; A: HCurve2d from Adaptor2d; Param: Real from Standard;
TLine,TArc: Transition from IntSurf) TLine,TArc: Transition from IntSurf)
---Purpose: Sets the value of the arc and of the parameter on ---Purpose: Sets the value of the arc and of the parameter on
@ -151,7 +151,7 @@ is
---Purpose: Returns the arc of restriction containing the ---Purpose: Returns the arc of restriction containing the
-- vertex. -- vertex.
returns any TheArc returns any HCurve2d from Adaptor2d
---C++: return const& ---C++: return const&
---C++: inline ---C++: inline
@ -221,7 +221,7 @@ is
-- IsVertex returns True. -- IsVertex returns True.
-- Otherwise, an exception is raised. -- Otherwise, an exception is raised.
returns any TheVertex returns any HVertex from Adaptor3d
---C++: return const& ---C++: return const&
---C++: inline ---C++: inline
@ -259,12 +259,12 @@ fields
vparam : Real from Standard; vparam : Real from Standard;
paraline : Real from Standard; paraline : Real from Standard;
onarc : Boolean from Standard; onarc : Boolean from Standard;
arc : TheArc; arc : HCurve2d from Adaptor2d;
traline : Transition from IntSurf; traline : Transition from IntSurf;
traarc : Transition from IntSurf; traarc : Transition from IntSurf;
prmarc : Real from Standard; prmarc : Real from Standard;
isvtx : Boolean from Standard; isvtx : Boolean from Standard;
vtx : TheVertex; vtx : HVertex from Adaptor3d;
ismult : Boolean from Standard; ismult : Boolean from Standard;
myInternal : Boolean from Standard; myInternal : Boolean from Standard;

14
src/Contap/Contap_Point.gxx → src/Contap/Contap_Point.cxx
View File

@ -14,14 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <Contap_Point.ixx>
Contap_Point::Contap_Point (): Contap_Point::Contap_Point ():
onarc(Standard_False),isvtx(Standard_False),ismult(Standard_False), onarc(Standard_False),isvtx(Standard_False),ismult(Standard_False),
myInternal(Standard_False) myInternal(Standard_False)
{} {}
Contap_Point::Contap_Point (const gp_Pnt& Pt, Contap_Point::Contap_Point (const gp_Pnt& Pt,
const Standard_Real U, const Standard_Real U,
const Standard_Real V): const Standard_Real V):
pt(Pt),uparam(U),vparam(V),onarc(Standard_False),isvtx(Standard_False), pt(Pt),uparam(U),vparam(V),onarc(Standard_False),isvtx(Standard_False),
ismult(Standard_False),myInternal(Standard_False) ismult(Standard_False),myInternal(Standard_False)
{} {}

8
src/Contap/Contap_Point.lxx
View File

@ -34,13 +34,13 @@ inline void Contap_Point::SetParameter (const Standard_Real Para) {
paraline = Para; paraline = Para;
} }
inline void Contap_Point::SetVertex(const TheVertex& V) { inline void Contap_Point::SetVertex(const Handle(Adaptor3d_HVertex)& V) {
isvtx = Standard_True; isvtx = Standard_True;
vtx = V; vtx = V;
} }
inline void Contap_Point::SetArc (const TheArc& A, inline void Contap_Point::SetArc (const Handle(Adaptor2d_HCurve2d)& A,
const Standard_Real Param, const Standard_Real Param,
const IntSurf_Transition& TLine, const IntSurf_Transition& TLine,
const IntSurf_Transition& TArc) { const IntSurf_Transition& TArc) {
@ -94,7 +94,7 @@ inline Standard_Boolean Contap_Point::IsOnArc () const{
return onarc; return onarc;
} }
inline const TheArc& Contap_Point::Arc () const { inline const Handle_Adaptor2d_HCurve2d& Contap_Point::Arc () const {
if (!onarc) {Standard_DomainError::Raise();} if (!onarc) {Standard_DomainError::Raise();}
return arc; return arc;
@ -122,7 +122,7 @@ inline Standard_Boolean Contap_Point::IsVertex () const {
return isvtx; return isvtx;
} }
inline const TheVertex& Contap_Point::Vertex () const { inline const Handle_Adaptor3d_HVertex& Contap_Point::Vertex () const {
if (!isvtx) {Standard_DomainError::Raise();} if (!isvtx) {Standard_DomainError::Raise();}
return vtx; return vtx;

32
src/Contap/Contap_SurfFunction.cdl
View File

@ -14,27 +14,23 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class SurfFunction from Contap class SurfFunction from Contap inherits FunctionSetWithDerivatives from math
(TheSurface as any;
TheSurfaceTool as any;
TheSurfProps as any; -- as SurfProps from Contap(TheSurface,
-- TheSurfaceTool)
TheContTool as any)
inherits FunctionSetWithDerivatives from math
---Purpose: This class describes the function on a parametric surface. ---Purpose: This class describes the function on a parametric surface.
-- the form of the function is F(u,v) = 0 where u and v are -- the form of the function is F(u,v) = 0 where u and v are
-- the parameteric coordinates of a point on the surface, -- the parameteric coordinates of a point on the surface,
-- to compute the contours of the surface. -- to compute the contours of the surface.
uses Vector from math, uses Vector from math,
Matrix from math, Matrix from math,
Pnt from gp, Pnt from gp,
Vec from gp, Vec from gp,
Dir from gp, Dir from gp,
Dir2d from gp, Dir2d from gp,
TFunction from Contap TFunction from Contap,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
HContTool from Contap
raises UndefinedDerivative from StdFail raises UndefinedDerivative from StdFail
@ -46,7 +42,7 @@ is
returns SurfFunction from Contap; returns SurfFunction from Contap;
Set(me: in out; S: TheSurface) Set(me: in out; S: HSurface from Adaptor3d)
is static; is static;
@ -203,7 +199,7 @@ is
Surface(me) Surface(me)
returns any TheSurface returns any HSurface from Adaptor3d
---C++: return const& ---C++: return const&
---C++: inline ---C++: inline
is static; is static;
@ -212,7 +208,7 @@ is
fields fields
mySurf : TheSurface; mySurf : HSurface from Adaptor3d;
myMean : Real from Standard; myMean : Real from Standard;
myType : TFunction from Contap; myType : TFunction from Contap;
myDir : Dir from gp; myDir : Dir from gp;

158
src/Contap/Contap_SurfFunction.gxx → src/Contap/Contap_SurfFunction.cxx
View File

@ -16,34 +16,36 @@
// jag 940616 #define Tolpetit 1.e-16 // jag 940616 #define Tolpetit 1.e-16
#include <Contap_SurfFunction.ixx>
#include <gp.hxx> #include <Contap_SurfProps.hxx>
#include <Contap_HContTool.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
Contap_SurfFunction::Contap_SurfFunction (): Contap_SurfFunction::Contap_SurfFunction ():
myMean(1.), myMean(1.),
myType(Contap_ContourStd), myType(Contap_ContourStd),
myDir(0.,0.,1.), myDir(0.,0.,1.),
myCosAng(0.), // PI/2 - Angle de depouille myCosAng(0.), // PI/2 - Angle de depouille
tol(1.e-6), tol(1.e-6),
computed(Standard_False), computed(Standard_False),
derived(Standard_False) derived(Standard_False)
{} {}
void Contap_SurfFunction::Set(const TheSurface& S) void Contap_SurfFunction::Set(const Handle(Adaptor3d_HSurface)& S)
{ {
mySurf = S; mySurf = S;
Standard_Integer i; Standard_Integer i;
Standard_Integer nbs = TheContTool::NbSamplePoints(S); Standard_Integer nbs = Contap_HContTool::NbSamplePoints(S);
Standard_Real U,V; Standard_Real U,V;
gp_Vec norm; gp_Vec norm;
if (nbs > 0) { if (nbs > 0) {
myMean = 0.; myMean = 0.;
for (i = 1; i <= nbs; i++) { for (i = 1; i <= nbs; i++) {
TheContTool::SamplePoint(S,i,U,V); Contap_HContTool::SamplePoint(S,i,U,V);
// TheSurfaceTool::D1(S,U,V,solpt,d1u,d1v); // Adaptor3d_HSurfaceTool::D1(S,U,V,solpt,d1u,d1v);
// myMean = myMean + d1u.Crossed(d1v).Magnitude(); // myMean = myMean + d1u.Crossed(d1v).Magnitude();
TheSurfProps::Normale(S,U,V,solpt,norm); Contap_SurfProps::Normale(S,U,V,solpt,norm);
myMean = myMean + norm.Magnitude(); myMean = myMean + norm.Magnitude();
} }
myMean = myMean / ((Standard_Real)nbs); myMean = myMean / ((Standard_Real)nbs);
@ -65,13 +67,13 @@ Standard_Integer Contap_SurfFunction::NbEquations () const
Standard_Boolean Contap_SurfFunction::Value(const math_Vector& X, Standard_Boolean Contap_SurfFunction::Value(const math_Vector& X,
math_Vector& F) math_Vector& F)
{ {
Usol = X(1); Vsol = X(2); Usol = X(1); Vsol = X(2);
// TheSurfaceTool::D1(mySurf,Usol,Vsol,solpt,d1u,d1v); // Adaptor3d_HSurfaceTool::D1(mySurf,Usol,Vsol,solpt,d1u,d1v);
// gp_Vec norm(d1u.Crossed(d1v)); // gp_Vec norm(d1u.Crossed(d1v));
gp_Vec norm; gp_Vec norm;
TheSurfProps::Normale(mySurf,Usol,Vsol,solpt,norm); Contap_SurfProps::Normale(mySurf,Usol,Vsol,solpt,norm);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
@ -99,20 +101,20 @@ Standard_Boolean Contap_SurfFunction::Value(const math_Vector& X,
Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X, Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X,
math_Matrix& Grad) math_Matrix& Grad)
{ {
// gp_Vec d2u,d2v,d2uv; // gp_Vec d2u,d2v,d2uv;
Usol = X(1); Vsol = X(2); Usol = X(1); Vsol = X(2);
// TheSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv); // Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
gp_Vec norm,dnu,dnv; gp_Vec norm,dnu,dnv;
TheSurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv); Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
// Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean; // Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
// Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean; // Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
Grad(1,1) = (dnu.Dot(myDir))/myMean; Grad(1,1) = (dnu.Dot(myDir))/myMean;
Grad(1,2) = (dnv.Dot(myDir))/myMean; Grad(1,2) = (dnv.Dot(myDir))/myMean;
} }
@ -126,11 +128,11 @@ Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X,
break; break;
case Contap_DraftStd: case Contap_DraftStd:
{ {
// gp_Vec norm(d1u.Crossed(d1v).Normalized()); // gp_Vec norm(d1u.Crossed(d1v).Normalized());
// gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv)); // gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
// Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; // Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
// dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v); // dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
// Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; // Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
norm.Normalize(); norm.Normalize();
Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean; Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean; Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
@ -149,24 +151,24 @@ Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X,
Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X, Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X,
math_Vector& F, math_Vector& F,
math_Matrix& Grad) math_Matrix& Grad)
{ {
// gp_Vec d2u,d2v,d2uv; // gp_Vec d2u,d2v,d2uv;
Usol = X(1); Vsol = X(2); Usol = X(1); Vsol = X(2);
// TheSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv); // Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
// gp_Vec norm(d1u.Crossed(d1v)); // gp_Vec norm(d1u.Crossed(d1v));
gp_Vec norm,dnu,dnv; gp_Vec norm,dnu,dnv;
TheSurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv); Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
F(1) = (norm.Dot(myDir))/myMean; F(1) = (norm.Dot(myDir))/myMean;
// Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean; // Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
// Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean; // Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
Grad(1,1) = (dnu.Dot(myDir))/myMean; Grad(1,1) = (dnu.Dot(myDir))/myMean;
Grad(1,2) = (dnv.Dot(myDir))/myMean; Grad(1,2) = (dnv.Dot(myDir))/myMean;
} }
@ -175,8 +177,8 @@ Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X,
{ {
gp_Vec Ep(myEye,solpt); gp_Vec Ep(myEye,solpt);
F(1) = (norm.Dot(Ep))/myMean; F(1) = (norm.Dot(Ep))/myMean;
// Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean; // Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
// Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean; // Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
Grad(1,1) = (dnu.Dot(Ep))/myMean; Grad(1,1) = (dnu.Dot(Ep))/myMean;
Grad(1,2) = (dnv.Dot(Ep))/myMean; Grad(1,2) = (dnv.Dot(Ep))/myMean;
} }
@ -185,12 +187,12 @@ Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X,
{ {
F(1) = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean; F(1) = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
norm.Normalize(); norm.Normalize();
/* /*
gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv)); gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v); dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
*/ */
Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean; Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean; Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
} }
@ -213,47 +215,47 @@ Standard_Boolean Contap_SurfFunction::IsTangent ()
if (!computed) { if (!computed) {
computed = Standard_True; computed = Standard_True;
if(!derived) { if(!derived) {
// gp_Vec d2u,d2v,d2uv; // gp_Vec d2u,d2v,d2uv;
// TheSurfaceTool::D2(mySurf, Usol, Vsol, solpt, d1u, d1v, d2u, d2v, d2uv); // Adaptor3d_HSurfaceTool::D2(mySurf, Usol, Vsol, solpt, d1u, d1v, d2u, d2v, d2uv);
gp_Vec norm,dnu,dnv; gp_Vec norm,dnu,dnv;
TheSurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv); Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
switch (myType) { switch (myType) {
case Contap_ContourStd: case Contap_ContourStd:
{ {
// Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean; // Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
// Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean; // Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
Fpu = (dnu.Dot(myDir))/myMean; Fpu = (dnu.Dot(myDir))/myMean;
Fpv = (dnv.Dot(myDir))/myMean; Fpv = (dnv.Dot(myDir))/myMean;
} }
break; break;
case Contap_ContourPrs: case Contap_ContourPrs:
{ {
gp_Vec Ep(myEye,solpt); gp_Vec Ep(myEye,solpt);
// Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean; // Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
// Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean; // Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
Fpu = (dnu.Dot(Ep))/myMean; Fpu = (dnu.Dot(Ep))/myMean;
Fpv = (dnv.Dot(Ep))/myMean; Fpv = (dnv.Dot(Ep))/myMean;
} }
break; break;
case Contap_DraftStd: case Contap_DraftStd:
{ {
/* /*
gp_Vec norm(d1u.Crossed(d1v).Normalized()); gp_Vec norm(d1u.Crossed(d1v).Normalized());
gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv)); gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
Fpu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; Fpu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v); dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
Fpv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean; Fpv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
*/ */
norm.Normalize(); norm.Normalize();
Fpu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean; Fpu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
Fpv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean; Fpv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
} }
break; break;
case Contap_DraftPrs: case Contap_DraftPrs:
default: default:
{ {
} }
} }
derived = Standard_True; derived = Standard_True;
} }
@ -266,15 +268,15 @@ Standard_Boolean Contap_SurfFunction::IsTangent ()
else { else {
d2d = gp_Dir2d(-Fpv,Fpu); d2d = gp_Dir2d(-Fpv,Fpu);
gp_Vec d1u,d1v; gp_Vec d1u,d1v;
TheSurfaceTool::D1(mySurf, Usol, Vsol, solpt, d1u, d1v); // ajout jag 02.95 Adaptor3d_HSurfaceTool::D1(mySurf, Usol, Vsol, solpt, d1u, d1v); // ajout jag 02.95
gp_XYZ d3dxyz(-Fpv*d1u.XYZ()); gp_XYZ d3dxyz(-Fpv*d1u.XYZ());
d3dxyz.Add(Fpu*d1v.XYZ()); d3dxyz.Add(Fpu*d1v.XYZ());
d3d.SetXYZ(d3dxyz); d3d.SetXYZ(d3dxyz);
//jag 940616 if (d3d.Magnitude() <= Tolpetit) { //jag 940616 if (d3d.Magnitude() <= Tolpetit) {
if (d3d.Magnitude() <= tol) { if (d3d.Magnitude() <= tol) {
tangent = Standard_True; tangent = Standard_True;
} }
} }
} }

2
src/Contap/Contap_SurfFunction.lxx
View File

@ -80,7 +80,7 @@ inline const gp_Dir2d& Contap_SurfFunction::Direction2d()
return d2d; return d2d;
} }
inline const TheSurface& Contap_SurfFunction::Surface() const inline const Handle_Adaptor3d_HSurface& Contap_SurfFunction::Surface() const
{ {
return mySurf; return mySurf;
} }

16
src/Contap/Contap_SurfProps.cdl
View File

@ -14,19 +14,19 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class SurfProps from Contap class SurfProps from Contap
(TheSurface as any;
TheSurfaceTool as any)
---Purpose: Internal tool used to compute the normal and its ---Purpose: Internal tool used to compute the normal and its
-- derivatives. -- derivatives.
uses Pnt from gp, uses Pnt from gp,
Vec from gp Vec from gp,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d
is is
Normale(myclass; S: TheSurface; U,V: Real from Standard; Normale(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P: out Pnt from gp; P: out Pnt from gp;
N: out Vec from gp); N: out Vec from gp);
@ -35,7 +35,7 @@ is
DerivAndNorm(myclass; S: TheSurface; U,V: Real from Standard; DerivAndNorm(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P : out Pnt from gp; P : out Pnt from gp;
d1u,d1v: out Vec from gp; d1u,d1v: out Vec from gp;
N : out Vec from gp); N : out Vec from gp);
@ -45,7 +45,7 @@ is
NormAndDn(myclass; S: TheSurface; U,V: Real from Standard; NormAndDn(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P : out Pnt from gp; P : out Pnt from gp;
N,Dnu,Dnv: out Vec from gp); N,Dnu,Dnv: out Vec from gp);

207
src/Contap/Contap_SurfProps.gxx → src/Contap/Contap_SurfProps.cxx
View File

@ -14,29 +14,32 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <Contap_SurfProps.ixx>
#include <ElSLib.hxx> #include <ElSLib.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
//======================================================================= //=======================================================================
//function : Normale //function : Normale
//purpose : //purpose :
//======================================================================= //=======================================================================
void Contap_SurfProps::Normale(const TheSurface& S, void Contap_SurfProps::Normale(const Handle(Adaptor3d_HSurface)& S,
const Standard_Real U, const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& Norm) gp_Vec& Norm)
{ {
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(S); GeomAbs_SurfaceType typS = Adaptor3d_HSurfaceTool::GetType(S);
switch (typS) { switch (typS) {
case GeomAbs_Plane: case GeomAbs_Plane:
{ {
gp_Pln pl(TheSurfaceTool::Plane(S)); gp_Pln pl(Adaptor3d_HSurfaceTool::Plane(S));
Norm = pl.Axis().Direction(); Norm = pl.Axis().Direction();
P = ElSLib::Value(U,V,pl); P = ElSLib::Value(U,V,pl);
if (!pl.Direct()) { if (!pl.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
@ -44,26 +47,26 @@ void Contap_SurfProps::Normale(const TheSurface& S,
case GeomAbs_Sphere: case GeomAbs_Sphere:
{ {
gp_Sphere sp(TheSurfaceTool::Sphere(S)); gp_Sphere sp(Adaptor3d_HSurfaceTool::Sphere(S));
P = ElSLib::Value(U,V,sp); P = ElSLib::Value(U,V,sp);
Norm = gp_Vec(sp.Location(),P); Norm = gp_Vec(sp.Location(),P);
if (sp.Direct()) { if (sp.Direct()) {
Norm.Divide(sp.Radius()); Norm.Divide(sp.Radius());
} }
else { else {
Norm.Divide(-sp.Radius()); Norm.Divide(-sp.Radius());
} }
} }
break; break;
case GeomAbs_Cylinder: case GeomAbs_Cylinder:
{ {
gp_Cylinder cy(TheSurfaceTool::Cylinder(S)); gp_Cylinder cy(Adaptor3d_HSurfaceTool::Cylinder(S));
P = ElSLib::Value(U,V,cy); P = ElSLib::Value(U,V,cy);
Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(), Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(),
Sin(U),cy.YAxis().Direction()); Sin(U),cy.YAxis().Direction());
if (!cy.Direct()) { if (!cy.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
@ -71,7 +74,7 @@ void Contap_SurfProps::Normale(const TheSurface& S,
case GeomAbs_Cone: case GeomAbs_Cone:
{ {
gp_Cone co(TheSurfaceTool::Cone(S)); gp_Cone co(Adaptor3d_HSurfaceTool::Cone(S));
P = ElSLib::Value(U,V,co); P = ElSLib::Value(U,V,co);
Standard_Real Angle = co.SemiAngle(); Standard_Real Angle = co.SemiAngle();
Standard_Real Sina = sin(Angle); Standard_Real Sina = sin(Angle);
@ -80,38 +83,38 @@ void Contap_SurfProps::Normale(const TheSurface& S,
Standard_Real Vcalc = V; Standard_Real Vcalc = V;
if (Abs(V*Sina + Rad) <= 1e-12) { // on est a l`apex if (Abs(V*Sina + Rad) <= 1e-12) { // on est a l`apex
/* /*
Standard_Real Vfi = TheSurfaceTool::FirstVParameter(S); Standard_Real Vfi = Adaptor3d_HSurfaceTool::FirstVParameter(S);
if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex
Vcalc = V - 1; Vcalc = V - 1;
} }
else { else {
Vcalc = V + 1.; Vcalc = V + 1.;
} }
*/ */
Norm.SetCoord(0,0,0); Norm.SetCoord(0,0,0);
return; return;
} }
if (Rad + Vcalc*Sina < 0.) { if (Rad + Vcalc*Sina < 0.) {
Norm.SetLinearForm(Sina, co.Axis().Direction(), Norm.SetLinearForm(Sina, co.Axis().Direction(),
Cosa*cos(U),co.XAxis().Direction(), Cosa*cos(U),co.XAxis().Direction(),
Cosa*sin(U),co.YAxis().Direction()); Cosa*sin(U),co.YAxis().Direction());
} }
else { else {
Norm.SetLinearForm(-Sina, co.Axis().Direction(), Norm.SetLinearForm(-Sina, co.Axis().Direction(),
Cosa*cos(U),co.XAxis().Direction(), Cosa*cos(U),co.XAxis().Direction(),
Cosa*sin(U),co.YAxis().Direction()); Cosa*sin(U),co.YAxis().Direction());
} }
if (!co.Direct()) { if (!co.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
default: default:
{ {
gp_Vec d1u,d1v; gp_Vec d1u,d1v;
TheSurfaceTool::D1(S,U,V,P,d1u,d1v); Adaptor3d_HSurfaceTool::D1(S,U,V,P,d1u,d1v);
Norm = d1u.Crossed(d1v); Norm = d1u.Crossed(d1v);
} }
break; break;
@ -126,24 +129,24 @@ void Contap_SurfProps::Normale(const TheSurface& S,
//purpose : //purpose :
//======================================================================= //=======================================================================
void Contap_SurfProps::DerivAndNorm(const TheSurface& S, void Contap_SurfProps::DerivAndNorm(const Handle(Adaptor3d_HSurface)& S,
const Standard_Real U, const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& d1u, gp_Vec& d1u,
gp_Vec& d1v, gp_Vec& d1v,
gp_Vec& Norm) gp_Vec& Norm)
{ {
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(S); GeomAbs_SurfaceType typS = Adaptor3d_HSurfaceTool::GetType(S);
switch (typS) { switch (typS) {
case GeomAbs_Plane: case GeomAbs_Plane:
{ {
gp_Pln pl(TheSurfaceTool::Plane(S)); gp_Pln pl(Adaptor3d_HSurfaceTool::Plane(S));
Norm = pl.Axis().Direction(); Norm = pl.Axis().Direction();
ElSLib::D1(U,V,pl,P,d1u,d1v); ElSLib::D1(U,V,pl,P,d1u,d1v);
if (!pl.Direct()) { if (!pl.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
@ -151,26 +154,26 @@ void Contap_SurfProps::DerivAndNorm(const TheSurface& S,
case GeomAbs_Sphere: case GeomAbs_Sphere:
{ {
gp_Sphere sp(TheSurfaceTool::Sphere(S)); gp_Sphere sp(Adaptor3d_HSurfaceTool::Sphere(S));
ElSLib::D1(U,V,sp,P,d1u,d1v); ElSLib::D1(U,V,sp,P,d1u,d1v);
Norm = gp_Vec(sp.Location(),P); Norm = gp_Vec(sp.Location(),P);
if (sp.Direct()) { if (sp.Direct()) {
Norm.Divide(sp.Radius()); Norm.Divide(sp.Radius());
} }
else { else {
Norm.Divide(-sp.Radius()); Norm.Divide(-sp.Radius());
} }
} }
break; break;
case GeomAbs_Cylinder: case GeomAbs_Cylinder:
{ {
gp_Cylinder cy(TheSurfaceTool::Cylinder(S)); gp_Cylinder cy(Adaptor3d_HSurfaceTool::Cylinder(S));
ElSLib::D1(U,V,cy,P,d1u,d1v); ElSLib::D1(U,V,cy,P,d1u,d1v);
Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(), Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(),
Sin(U),cy.YAxis().Direction()); Sin(U),cy.YAxis().Direction());
if (!cy.Direct()) { if (!cy.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
@ -178,7 +181,7 @@ void Contap_SurfProps::DerivAndNorm(const TheSurface& S,
case GeomAbs_Cone: case GeomAbs_Cone:
{ {
gp_Cone co(TheSurfaceTool::Cone(S)); gp_Cone co(Adaptor3d_HSurfaceTool::Cone(S));
ElSLib::D1(U,V,co,P,d1u,d1v); ElSLib::D1(U,V,co,P,d1u,d1v);
Standard_Real Angle = co.SemiAngle(); Standard_Real Angle = co.SemiAngle();
Standard_Real Sina = Sin(Angle); Standard_Real Sina = Sin(Angle);
@ -187,33 +190,33 @@ void Contap_SurfProps::DerivAndNorm(const TheSurface& S,
Standard_Real Vcalc = V; Standard_Real Vcalc = V;
if (Abs(V*Sina + Rad) <= RealEpsilon()) { // on est a l`apex if (Abs(V*Sina + Rad) <= RealEpsilon()) { // on est a l`apex
Standard_Real Vfi = TheSurfaceTool::FirstVParameter(S); Standard_Real Vfi = Adaptor3d_HSurfaceTool::FirstVParameter(S);
if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex
Vcalc = V - 1; Vcalc = V - 1;
} }
else { else {
Vcalc = V + 1.; Vcalc = V + 1.;
} }
} }
if (Rad + Vcalc*Sina < 0.) { if (Rad + Vcalc*Sina < 0.) {
Norm.SetLinearForm(Sina, co.Axis().Direction(), Norm.SetLinearForm(Sina, co.Axis().Direction(),
Cosa*Cos(U),co.XAxis().Direction(), Cosa*Cos(U),co.XAxis().Direction(),
Cosa*Sin(U),co.YAxis().Direction()); Cosa*Sin(U),co.YAxis().Direction());
} }
else { else {
Norm.SetLinearForm(-Sina, co.Axis().Direction(), Norm.SetLinearForm(-Sina, co.Axis().Direction(),
Cosa*Cos(U),co.XAxis().Direction(), Cosa*Cos(U),co.XAxis().Direction(),
Cosa*Sin(U),co.YAxis().Direction()); Cosa*Sin(U),co.YAxis().Direction());
} }
if (!co.Direct()) { if (!co.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
} }
break; break;
default: default:
{ {
TheSurfaceTool::D1(S,U,V,P,d1u,d1v); Adaptor3d_HSurfaceTool::D1(S,U,V,P,d1u,d1v);
Norm = d1u.Crossed(d1v); Norm = d1u.Crossed(d1v);
} }
break; break;
@ -226,24 +229,24 @@ void Contap_SurfProps::DerivAndNorm(const TheSurface& S,
//purpose : //purpose :
//======================================================================= //=======================================================================
void Contap_SurfProps::NormAndDn(const TheSurface& S, void Contap_SurfProps::NormAndDn(const Handle(Adaptor3d_HSurface)& S,
const Standard_Real U, const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& Norm, gp_Vec& Norm,
gp_Vec& Dnu, gp_Vec& Dnu,
gp_Vec& Dnv) gp_Vec& Dnv)
{ {
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(S); GeomAbs_SurfaceType typS = Adaptor3d_HSurfaceTool::GetType(S);
switch (typS) { switch (typS) {
case GeomAbs_Plane: case GeomAbs_Plane:
{ {
gp_Pln pl(TheSurfaceTool::Plane(S)); gp_Pln pl(Adaptor3d_HSurfaceTool::Plane(S));
P = ElSLib::Value(U,V,pl); P = ElSLib::Value(U,V,pl);
Norm = pl.Axis().Direction(); Norm = pl.Axis().Direction();
if (!pl.Direct()) { if (!pl.Direct()) {
Norm.Reverse(); Norm.Reverse();
} }
Dnu = Dnv = gp_Vec(0.,0.,0.); Dnu = Dnv = gp_Vec(0.,0.,0.);
} }
@ -251,12 +254,12 @@ void Contap_SurfProps::NormAndDn(const TheSurface& S,
case GeomAbs_Sphere: case GeomAbs_Sphere:
{ {
gp_Sphere sp(TheSurfaceTool::Sphere(S)); gp_Sphere sp(Adaptor3d_HSurfaceTool::Sphere(S));
ElSLib::D1(U,V,sp,P,Dnu,Dnv); ElSLib::D1(U,V,sp,P,Dnu,Dnv);
Norm = gp_Vec(sp.Location(),P); Norm = gp_Vec(sp.Location(),P);
Standard_Real Rad = sp.Radius(); Standard_Real Rad = sp.Radius();
if (!sp.Direct()) { if (!sp.Direct()) {
Rad = -Rad; Rad = -Rad;
} }
Norm.Divide(Rad); Norm.Divide(Rad);
Dnu.Divide(Rad); Dnu.Divide(Rad);
@ -266,15 +269,15 @@ void Contap_SurfProps::NormAndDn(const TheSurface& S,
case GeomAbs_Cylinder: case GeomAbs_Cylinder:
{ {
gp_Cylinder cy(TheSurfaceTool::Cylinder(S)); gp_Cylinder cy(Adaptor3d_HSurfaceTool::Cylinder(S));
P = ElSLib::Value(U,V,cy); P = ElSLib::Value(U,V,cy);
Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(), Norm.SetLinearForm(Cos(U),cy.XAxis().Direction(),
Sin(U),cy.YAxis().Direction()); Sin(U),cy.YAxis().Direction());
Dnu.SetLinearForm(-Sin(U),cy.XAxis().Direction(), Dnu.SetLinearForm(-Sin(U),cy.XAxis().Direction(),
Cos(U),cy.YAxis().Direction()); Cos(U),cy.YAxis().Direction());
if (!cy.Direct()) { if (!cy.Direct()) {
Norm.Reverse(); Norm.Reverse();
Dnu.Reverse(); Dnu.Reverse();
} }
Dnv = gp_Vec(0.,0.,0.); Dnv = gp_Vec(0.,0.,0.);
} }
@ -283,7 +286,7 @@ void Contap_SurfProps::NormAndDn(const TheSurface& S,
case GeomAbs_Cone: case GeomAbs_Cone:
{ {
gp_Cone co(TheSurfaceTool::Cone(S)); gp_Cone co(Adaptor3d_HSurfaceTool::Cone(S));
P = ElSLib::Value(U,V,co); P = ElSLib::Value(U,V,co);
Standard_Real Angle = co.SemiAngle(); Standard_Real Angle = co.SemiAngle();
Standard_Real Sina = Sin(Angle); Standard_Real Sina = Sin(Angle);
@ -291,39 +294,39 @@ void Contap_SurfProps::NormAndDn(const TheSurface& S,
Standard_Real Rad = co.RefRadius(); Standard_Real Rad = co.RefRadius();
Standard_Real Vcalc = V; Standard_Real Vcalc = V;
if (Abs(V*Sina + Rad) <= RealEpsilon()) { // on est a l`apex if (Abs(V*Sina + Rad) <= RealEpsilon()) { // on est a l`apex
Standard_Real Vfi = TheSurfaceTool::FirstVParameter(S); Standard_Real Vfi = Adaptor3d_HSurfaceTool::FirstVParameter(S);
if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex if (Vfi < -Rad/Sina) { // partie valide pour V < Vapex
Vcalc = V - 1; Vcalc = V - 1;
} }
else { else {
Vcalc = V + 1.; Vcalc = V + 1.;
} }
} }
if (Rad + Vcalc*Sina < 0.) { if (Rad + Vcalc*Sina < 0.) {
Norm.SetLinearForm(Sina, co.Axis().Direction(), Norm.SetLinearForm(Sina, co.Axis().Direction(),
Cosa*Cos(U),co.XAxis().Direction(), Cosa*Cos(U),co.XAxis().Direction(),
Cosa*Sin(U),co.YAxis().Direction()); Cosa*Sin(U),co.YAxis().Direction());
} }
else { else {
Norm.SetLinearForm(-Sina, co.Axis().Direction(), Norm.SetLinearForm(-Sina, co.Axis().Direction(),
Cosa*Cos(U),co.XAxis().Direction(), Cosa*Cos(U),co.XAxis().Direction(),
Cosa*Sin(U),co.YAxis().Direction()); Cosa*Sin(U),co.YAxis().Direction());
} }
Dnu.SetLinearForm(-Cosa*Sin(U),co.XAxis().Direction(), Dnu.SetLinearForm(-Cosa*Sin(U),co.XAxis().Direction(),
Cosa*Cos(U),co.YAxis().Direction()); Cosa*Cos(U),co.YAxis().Direction());
if (!co.Direct()) { if (!co.Direct()) {
Norm.Reverse(); Norm.Reverse();
Dnu.Reverse(); Dnu.Reverse();
} }
Dnv = gp_Vec(0.,0.,0.); Dnv = gp_Vec(0.,0.,0.);
} }
break; break;
default: default:
{ {
gp_Vec d1u,d1v,d2u,d2v,d2uv; gp_Vec d1u,d1v,d2u,d2v,d2uv;
TheSurfaceTool::D2(S,U,V,P,d1u,d1v,d2u,d2v,d2uv); Adaptor3d_HSurfaceTool::D2(S,U,V,P,d1u,d1v,d2u,d2v,d2uv);
Norm = d1u.Crossed(d1v); Norm = d1u.Crossed(d1v);
Dnu = d2u.Crossed(d1v) + d1u.Crossed(d2uv); Dnu = d2u.Crossed(d1v) + d1u.Crossed(d2uv);
Dnv = d2uv.Crossed(d1v) + d1u.Crossed(d2v); Dnv = d2uv.Crossed(d1v) + d1u.Crossed(d2v);

3
src/Contap/FILES
View File

@ -1,3 +0,0 @@
Contap_ContourGen_1.gxx
Contap_ContourGen_2.gxx
Contap_ContourGen_3.gxx

6
src/HLRTopoBRep/HLRTopoBRep_DSFiller.cdl
View File

@ -26,7 +26,7 @@ uses
Face from TopoDS, Face from TopoDS,
Edge from TopoDS, Edge from TopoDS,
Vertex from TopoDS, Vertex from TopoDS,
ThePointOfContour from Contap, Point from Contap,
Contour from Contap, Contour from Contap,
Data from HLRTopoBRep, Data from HLRTopoBRep,
MapOfShapeTool from BRepTopAdaptor MapOfShapeTool from BRepTopAdaptor
@ -52,7 +52,7 @@ is
is private; is private;
MakeVertex(myclass; MakeVertex(myclass;
P : ThePointOfContour from Contap; P : Point from Contap;
tol : Real from Standard; tol : Real from Standard;
DS : in out Data from HLRTopoBRep) DS : in out Data from HLRTopoBRep)
returns Vertex from TopoDS returns Vertex from TopoDS
@ -61,7 +61,7 @@ is
is private; is private;
InsertVertex(myclass; InsertVertex(myclass;
P : ThePointOfContour from Contap; P : Point from Contap;
tol : Real from Standard; tol : Real from Standard;
E : Edge from TopoDS; E : Edge from TopoDS;
DS : in out Data from HLRTopoBRep) DS : in out Data from HLRTopoBRep)

16
src/HLRTopoBRep/HLRTopoBRep_DSFiller.cxx
View File

@ -44,7 +44,7 @@
#include <BRepTopAdaptor_HVertex.hxx> #include <BRepTopAdaptor_HVertex.hxx>
#include <BRepTopAdaptor_TopolTool.hxx> #include <BRepTopAdaptor_TopolTool.hxx>
#include <BRepTopAdaptor_Tool.hxx> #include <BRepTopAdaptor_Tool.hxx>
#include <Contap_TheLineOfContour.hxx> #include <Contap_Line.hxx>
#include <Extrema_LocateExtPC.hxx> #include <Extrema_LocateExtPC.hxx>
#include <Standard_ProgramError.hxx> #include <Standard_ProgramError.hxx>
#include <Precision.hxx> #include <Precision.hxx>
@ -197,7 +197,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
Standard_Integer CurLine; Standard_Integer CurLine;
for (CurLine = 1; CurLine <= NbLines; CurLine++) for (CurLine = 1; CurLine <= NbLines; CurLine++)
{ {
const Contap_TheLineOfContour& Line = FO.Line(CurLine); const Contap_Line& Line = FO.Line(CurLine);
const Standard_Integer NbPoints = Line.NbVertex(); const Standard_Integer NbPoints = Line.NbVertex();
Standard_Integer CurPoint; Standard_Integer CurPoint;
if (Line.TypeContour() == Contap_Restriction) if (Line.TypeContour() == Contap_Restriction)
@ -209,7 +209,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
// insert the Internal points. // insert the Internal points.
for (CurPoint = 1; CurPoint <= NbPoints; CurPoint++) { for (CurPoint = 1; CurPoint <= NbPoints; CurPoint++) {
Contap_ThePointOfContour P = Line.Vertex(CurPoint); Contap_Point P = Line.Vertex(CurPoint);
if (P.IsInternal()) { if (P.IsInternal()) {
if (P.Value().IsEqual(BRep_Tool::Pnt(VF),BRep_Tool::Tolerance(VF))) { if (P.Value().IsEqual(BRep_Tool::Pnt(VF),BRep_Tool::Tolerance(VF))) {
if (P.Value().IsEqual(BRep_Tool::Pnt(VL),BRep_Tool::Tolerance(VL))) { if (P.Value().IsEqual(BRep_Tool::Pnt(VL),BRep_Tool::Tolerance(VL))) {
@ -223,7 +223,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
{ {
for (CurPoint = 1; CurPoint <= NbPoints; CurPoint++) { for (CurPoint = 1; CurPoint <= NbPoints; CurPoint++) {
const Contap_ThePointOfContour PF = Line.Vertex(CurPoint); const Contap_Point PF = Line.Vertex(CurPoint);
if (PF.IsInternal() && CurPoint != 1) if (PF.IsInternal() && CurPoint != 1)
VF = VL; VF = VL;
else else
@ -231,7 +231,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
const Standard_Real parF = PF.ParameterOnLine(); const Standard_Real parF = PF.ParameterOnLine();
if (CurPoint < NbPoints) { if (CurPoint < NbPoints) {
const Contap_ThePointOfContour PL = Line.Vertex(CurPoint+1); const Contap_Point PL = Line.Vertex(CurPoint+1);
VL = MakeVertex(PL,tol,DS); VL = MakeVertex(PL,tol,DS);
const Standard_Real parL = PL.ParameterOnLine(); const Standard_Real parL = PL.ParameterOnLine();
@ -284,7 +284,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
/* /*
else if(ipL-ipF < 6) { else if(ipL-ipF < 6) {
// compute the tangents // compute the tangents
Contap_TheSurfFunctionOfContour& SFunc = Contap_SurfFunction& SFunc =
FO.SurfaceFunction(); FO.SurfaceFunction();
Standard_Boolean isTg1,isTg2; Standard_Boolean isTg1,isTg2;
@ -553,7 +553,7 @@ void HLRTopoBRep_DSFiller::InsertFace (const Standard_Integer /*FI*/,
//======================================================================= //=======================================================================
TopoDS_Vertex TopoDS_Vertex
HLRTopoBRep_DSFiller::MakeVertex (const Contap_ThePointOfContour& P, HLRTopoBRep_DSFiller::MakeVertex (const Contap_Point& P,
const Standard_Real tol, const Standard_Real tol,
HLRTopoBRep_Data& DS) HLRTopoBRep_Data& DS)
{ {
@ -611,7 +611,7 @@ HLRTopoBRep_DSFiller::MakeVertex (const Contap_ThePointOfContour& P,
//======================================================================= //=======================================================================
void void
HLRTopoBRep_DSFiller::InsertVertex (const Contap_ThePointOfContour& P, HLRTopoBRep_DSFiller::InsertVertex (const Contap_Point& P,
const Standard_Real tol, const Standard_Real tol,
const TopoDS_Edge& E, const TopoDS_Edge& E,
HLRTopoBRep_Data& DS) HLRTopoBRep_Data& DS)