Part 5) Trying to ge MakeBottle.cxx to compile.

Ok.. The original OCC download contained MakeBottle.cxx.  I copied
and rename the file an wanted to see if I can get one line to compile
at a time.  I also added a main() callout to give it some values
Anyway here it is:

#include <BRep_Tool.hxx>

#include <BRepAlgoAPI_Fuse.hxx>

#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
#include <BRepBuilderAPI_Transform.hxx>

#include <BRepFilletAPI_MakeFillet.hxx>

#include <BRepLib.hxx>

#include <BRepOffsetAPI_MakeThickSolid.hxx>
#include <BRepOffsetAPI_ThruSections.hxx>

#include <BRepPrimAPI_MakeCylinder.hxx>
#include <BRepPrimAPI_MakePrism.hxx>

#include <GC_MakeArcOfCircle.hxx>
#include <GC_MakeSegment.hxx>

#include <GCE2d_MakeSegment.hxx>

#include <gp.hxx>
#include <gp_Ax1.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf.hxx>
#include <gp_Vec.hxx>

#include <Geom_CylindricalSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
#include <Geom_TrimmedCurve.hxx>

#include <Geom2d_Ellipse.hxx>
#include <Geom2d_TrimmedCurve.hxx>

#include <TopExp_Explorer.hxx>

#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Compound.hxx>
#include <TopTools_ListOfShape.hxx>

TopoDS_Shape
MakeBottle(const Standard_Real myWidth , const Standard_Real myHeight ,
const Standard_Real myThickness)
{
//Profile : Define Support Points
gp_Pnt aPnt1(-myWidth / 2. , 0 , 0);
/*
gp_Pnt aPnt2(-myWidth / 2. , -myThickness / 4. , 0);
gp_Pnt aPnt3(0 , -myThickness / 2. , 0);
gp_Pnt aPnt4(myWidth / 2. , -myThickness / 4. , 0);
gp_Pnt aPnt5(myWidth / 2. , 0 , 0);

//Profile : Define the Geometry
Handle(Geom_TrimmedCurve) aArcOfCircle = GC_MakeArcOfCircle(aPnt2,aPnt3 ,aPnt4);
Handle(Geom_TrimmedCurve) aSegment1       = GC_MakeSegment(aPnt1 , aPnt2);
Handle(Geom_TrimmedCurve) aSegment2       = GC_MakeSegment(aPnt4 , aPnt5);

//Profile : Define the Topology
TopoDS_Edge aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1);
TopoDS_Edge aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle);
TopoDS_Edge aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2);
TopoDS_Wire aWire  = BRepBuilderAPI_MakeWire(aEdge1 , aEdge2 , aEdge3);

//Complete Profile
gp_Ax1 xAxis = gp::OX();
gp_Trsf aTrsf;

aTrsf.SetMirror(xAxis);

BRepBuilderAPI_Transform aBRepTrsf(aWire , aTrsf);
TopoDS_Shape aMirroredShape = aBRepTrsf.Shape();
TopoDS_Wire aMirroredWire = TopoDS::Wire(aMirroredShape);

BRepBuilderAPI_MakeWire mkWire;

mkWire.Add(aWire);
mkWire.Add(aMirroredWire);

TopoDS_Wire myWireProfile = mkWire.Wire();

//Body : Prism the Profile
TopoDS_Face myFaceProfile = BRepBuilderAPI_MakeFace(myWireProfile);
gp_Vec        aPrismVec(0 , 0 , myHeight);

TopoDS_Shape myBody = BRepPrimAPI_MakePrism(myFaceProfile , aPrismVec);

//Body : Apply Fillets
BRepFilletAPI_MakeFillet mkFillet(myBody);
TopExp_Explorer             aEdgeExplorer(myBody , TopAbs_EDGE);

while(aEdgeExplorer.More()){

TopoDS_Edge aEdge = TopoDS::Edge(aEdgeExplorer.Current());

//Add edge to fillet algorithm
mkFillet.Add(myThickness / 12. , aEdge);

aEdgeExplorer.Next();
}

myBody = mkFillet.Shape();

//Body : Add the Neck
gp_Pnt neckLocation(0 , 0 , myHeight);
gp_Dir neckNormal = gp::DZ();
gp_Ax2 neckAx2(neckLocation , neckNormal);

Standard_Real myNeckRadius = myThickness / 4.;
Standard_Real myNeckHeight = myHeight / 10;

BRepPrimAPI_MakeCylinder MKCylinder(neckAx2 , myNeckRadius , myNeckHeight);
TopoDS_Shape myNeck = MKCylinder.Shape();

myBody = BRepAlgoAPI_Fuse(myBody , myNeck);

//Body : Create a Hollowed Solid
TopoDS_Face   faceToRemove;
Standard_Real zMax = -1;

for(TopExp_Explorer aFaceExplorer(myBody , TopAbs_FACE) ; aFaceExplorer.More() ; aFaceExplorer.Next()){

TopoDS_Face aFace = TopoDS::Face(aFaceExplorer.Current());

//Check if <aFace> is the top face of the bottle’s neck
Handle(Geom_Surface) aSurface = BRep_Tool::Surface(aFace);

if(aSurface->DynamicType() == STANDARD_TYPE(Geom_Plane)){

Handle(Geom_Plane) aPlane = Handle(Geom_Plane)::DownCast(aSurface);

gp_Pnt          aPnt = aPlane->Location();
Standard_Real aZ   = aPnt.Z();

if(aZ > zMax){

zMax         = aZ;
faceToRemove = aFace;
}
}
}

TopTools_ListOfShape facesToRemove;

facesToRemove.Append(faceToRemove);

myBody = BRepOffsetAPI_MakeThickSolid(myBody , facesToRemove , -myThickness / 50 , 1.e-3);

//return myBody;
//Threading : Create Surfaces
Handle(Geom_CylindricalSurface) aCyl1 = new Geom_CylindricalSurface(neckAx2 , myNeckRadius * 0.99);
Handle(Geom_CylindricalSurface) aCyl2 = new Geom_CylindricalSurface(neckAx2 , myNeckRadius * 1.05);

//Threading : Define 2D Curves
gp_Pnt2d aPnt(2. * PI , myNeckHeight / 2.);
gp_Dir2d aDir(2. * PI , myNeckHeight / 4.);
gp_Ax2d aAx2d(aPnt , aDir);

Standard_Real aMajor = 2. * PI;
Standard_Real aMinor = myNeckHeight / 10;

Handle(Geom2d_Ellipse) anEllipse1 = new Geom2d_Ellipse(aAx2d , aMajor , aMinor);
Handle(Geom2d_Ellipse) anEllipse2 = new Geom2d_Ellipse(aAx2d , aMajor , aMinor / 4);

Handle(Geom2d_TrimmedCurve) aArc1 = new Geom2d_TrimmedCurve(anEllipse1 , 0 , PI);
Handle(Geom2d_TrimmedCurve) aArc2 = new Geom2d_TrimmedCurve(anEllipse2 , 0 , PI);

gp_Pnt2d anEllipsePnt1 = anEllipse1->Value(0);
gp_Pnt2d anEllipsePnt2 = anEllipse1->Value(PI);

Handle(Geom2d_TrimmedCurve) aSegment = GCE2d_MakeSegment(anEllipsePnt1 , anEllipsePnt2);

//Threading : Build Edges and Wires
TopoDS_Edge aEdge1OnSurf1 = BRepBuilderAPI_MakeEdge(aArc1 , aCyl1);
TopoDS_Edge aEdge2OnSurf1 = BRepBuilderAPI_MakeEdge(aSegment , aCyl1);
TopoDS_Edge aEdge1OnSurf2 = BRepBuilderAPI_MakeEdge(aArc2 , aCyl2);
TopoDS_Edge aEdge2OnSurf2 = BRepBuilderAPI_MakeEdge(aSegment , aCyl2);

TopoDS_Wire threadingWire1 = BRepBuilderAPI_MakeWire(aEdge1OnSurf1 , aEdge2OnSurf1);
TopoDS_Wire threadingWire2 = BRepBuilderAPI_MakeWire(aEdge1OnSurf2 , aEdge2OnSurf2);

BRepLib::BuildCurves3d(threadingWire1);
BRepLib::BuildCurves3d(threadingWire2);

//Create Threading
BRepOffsetAPI_ThruSections aTool(Standard_True);

aTool.AddWire(threadingWire1);
aTool.AddWire(threadingWire2);
aTool.CheckCompatibility(Standard_False);

TopoDS_Shape myThreading = aTool.Shape();

//Building the resulting compound
TopoDS_Compound aRes;
BRep_Builder aBuilder;
aBuilder.MakeCompound (aRes);

aBuilder.Add (aRes, myBody);
aBuilder.Add (aRes, myThreading);

return aRes;
*/
}
int main () {
MakeBottle(100 , 200 ,1);
}

This is pretty much the baseline code that comes OCC  to the first line of code.

Trying: g++  -I/usr/include/opencascade -DHAVE_CONFIG_H -DHAVE_IOSTREAM -DHAVE_FSTREAM -DMAVE_LIMITS_H MakeBottle_JT.cxx
Lead to:

/tmp/ccPBD47w.o: In function Handle_Standard_Transient::~Handle_Standard_Transient()':
MakeBottle_JT.cxx:(.text._ZN25Handle_Standard_TransientD2Ev[Handle_Standard_Transient::~Handle_Standard_Transient()]+0xd):
undefined reference to
Handle_Standard_Transient::EndScope()’
/tmp/ccPBD47w.o: In function TopLoc_SListOfItemLocation::~TopLoc_SListOfItemLocation()':
MakeBottle_JT.cxx:(.text._ZN26TopLoc_SListOfItemLocationD1Ev[TopLoc_SListOfItemLocation::~TopLoc_SListOfItemLocation()]+0xe):
undefined reference to
TopLoc_SListOfItemLocation::Clear()’
collect2: ld returned 1 exit status
jonas@Ubuntu4:~/OCC_bottle$

I was starting to research error message which led me to this link:
http://www.opencascade.org/org/forum/thread_11990/

I need to digest this a little bit.

Posted in Ubuntu, Uncategorized | 2 Comments

Part 4) Trying to get MakeBottle.cxx to compile

Tried:
jonas@Ubuntu4:~/OCC_bottle$ g++ -E -I/usr/include/opencascade -DHAVE_CONFIG_H MakeBottle.cxx 2>MakeBottle.with_DHAVE_CONFIG_H
In seems the precompiler didn’t choke on this.

When I removed the -E here are the results:
g++ -E -I/usr/include/opencascade -DHAVE_CONFIG_H MakeBottle.cxx 2>MakeBottle.with_DHAVE_CONFIG_H

In file included from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Mat.lxx: In member function ‘void gp_Mat::SetValue(Standard_Integer, Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Mat.lxx:98: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘const Standard_Real& gp_Mat::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Mat.lxx:115: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘Standard_Real& gp_Mat::ChangeValue(Standard_Integer, Standard_Integer)’:
/usr/include/opencascade/gp_Mat.lxx:123: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘void gp_Mat::Divide(Standard_Real)’:
/usr/include/opencascade/gp_Mat.lxx:173: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘gp_Mat gp_Mat::Divided(Standard_Real) const’:
/usr/include/opencascade/gp_Mat.lxx:192: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_XYZ.hxx:358,
from /usr/include/opencascade/gp_Trsf.hxx:35,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_XYZ.lxx: In member function ‘void gp_XYZ::Normalize()’:
/usr/include/opencascade/gp_XYZ.lxx:206: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_XYZ.lxx: In member function ‘gp_XYZ gp_XYZ::Normalized() const’:
/usr/include/opencascade/gp_XYZ.lxx:213: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Mat2d.hxx:292,
from /usr/include/opencascade/gp_Trsf2d.hxx:32,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘void gp_Mat2d::SetValue(Standard_Integer, Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Mat2d.lxx:62: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘const Standard_Real& gp_Mat2d::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Mat2d.lxx:76: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘Standard_Real& gp_Mat2d::ChangeValue(Standard_Integer, Standard_Integer)’:
/usr/include/opencascade/gp_Mat2d.lxx:85: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_XY.hxx:318,
from /usr/include/opencascade/gp_Trsf2d.hxx:35,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_XY.lxx: In member function ‘void gp_XY::Normalize()’:
/usr/include/opencascade/gp_XY.lxx:140: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_XY.lxx: In member function ‘gp_XY gp_XY::Normalized() const’:
/usr/include/opencascade/gp_XY.lxx:147: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Dir2d.hxx:304,
from /usr/include/opencascade/gp_Vec2d.lxx:5,
from /usr/include/opencascade/gp_Vec2d.hxx:339,
from /usr/include/opencascade/gp_Pnt2d.lxx:6,
from /usr/include/opencascade/gp_Pnt2d.hxx:204,
from /usr/include/opencascade/gp_Trsf2d.lxx:4,
from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(const gp_Vec2d&)’:
/usr/include/opencascade/gp_Dir2d.lxx:19: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(const gp_XY&)’:
/usr/include/opencascade/gp_Dir2d.lxx:29: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:38: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetCoord(Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:48: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx:52: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetCoord(Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:61: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetX(Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:70: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetY(Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:79: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetXY(const gp_XY&)’:
/usr/include/opencascade/gp_Dir2d.lxx:89: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Vec2d.hxx:339,
from /usr/include/opencascade/gp_Pnt2d.lxx:6,
from /usr/include/opencascade/gp_Pnt2d.hxx:204,
from /usr/include/opencascade/gp_Trsf2d.lxx:4,
from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Vec2d.lxx: In member function ‘void gp_Vec2d::Normalize()’:
/usr/include/opencascade/gp_Vec2d.lxx:140: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec2d.lxx: In member function ‘gp_Vec2d gp_Vec2d::Normalized() const’:
/usr/include/opencascade/gp_Vec2d.lxx:147: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Trsf2d.lxx: In member function ‘Standard_Real gp_Trsf2d::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Trsf2d.lxx:85: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Dir.hxx:313,
from /usr/include/opencascade/gp_Vec.lxx:6,
from /usr/include/opencascade/gp_Vec.hxx:388,
from /usr/include/opencascade/gp_Trsf.lxx:8,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(const gp_Vec&)’:
/usr/include/opencascade/gp_Dir.lxx:18: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(const gp_XYZ&)’:
/usr/include/opencascade/gp_Dir.lxx:30: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(Standard_Real, Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:41: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetCoord(Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:53: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx:58: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetCoord(Standard_Real, Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:68: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetX(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:79: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetY(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:90: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetZ(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:101: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetXYZ(const gp_XYZ&)’:
/usr/include/opencascade/gp_Dir.lxx:113: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::Cross(const gp_Dir&)’:
/usr/include/opencascade/gp_Dir.lxx:170: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘gp_Dir gp_Dir::Crossed(const gp_Dir&) const’:
/usr/include/opencascade/gp_Dir.lxx:179: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::CrossCross(const gp_Dir&, const gp_Dir&)’:
/usr/include/opencascade/gp_Dir.lxx:189: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘gp_Dir gp_Dir::CrossCrossed(const gp_Dir&, const gp_Dir&) const’:
/usr/include/opencascade/gp_Dir.lxx:199: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Vec.hxx:388,
from /usr/include/opencascade/gp_Trsf.lxx:8,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Vec.lxx: In member function ‘Standard_Real gp_Vec::Angle(const gp_Vec&) const’:
/usr/include/opencascade/gp_Vec.lxx:111: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘Standard_Real gp_Vec::AngleWithRef(const gp_Vec&, const gp_Vec&) const’:
/usr/include/opencascade/gp_Vec.lxx:120: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘void gp_Vec::Normalize()’:
/usr/include/opencascade/gp_Vec.lxx:213: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘gp_Vec gp_Vec::Normalized() const’:
/usr/include/opencascade/gp_Vec.lxx:220: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Trsf.lxx: In member function ‘Standard_Real gp_Trsf::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Trsf.lxx:69: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/BRepTools_Modifier.hxx:131,
from /usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx:26,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:35,
from MakeBottle.cxx:8:
/usr/include/opencascade/BRepTools_Modifier.lxx: In member function ‘const TopoDS_Shape& BRepTools_Modifier::ModifiedShape(const TopoDS_Shape&) const’:
/usr/include/opencascade/BRepTools_Modifier.lxx:17: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/TopoDS_Iterator.hxx:142,
from /usr/include/opencascade/TopExp_Explorer.lxx:6,
from /usr/include/opencascade/TopExp_Explorer.hxx:220,
from MakeBottle.cxx:44:
/usr/include/opencascade/TopoDS_Iterator.lxx: In member function ‘const TopoDS_Shape& TopoDS_Iterator::Value() const’:
/usr/include/opencascade/TopoDS_Iterator.lxx:26: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/TopoDS.hxx:168,
from MakeBottle.cxx:46:
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Vertex& TopoDS::Vertex(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:25: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Vertex& TopoDS::Vertex(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:37: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Edge& TopoDS::Edge(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:49: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Edge& TopoDS::Edge(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:61: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Wire& TopoDS::Wire(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:73: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Wire& TopoDS::Wire(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:85: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Face& TopoDS::Face(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:97: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Face& TopoDS::Face(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:109: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Shell& TopoDS::Shell(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:121: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Shell& TopoDS::Shell(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:133: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Solid& TopoDS::Solid(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:145: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Solid& TopoDS::Solid(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:157: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_CompSolid& TopoDS::CompSolid(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:169: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_CompSolid& TopoDS::CompSolid(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:181: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Compound& TopoDS::Compound(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:193: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Compound& TopoDS::Compound(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:205: warning: deprecated conversion from string constant to ‘char*’
/usr/lib/gcc/i486-linux-gnu/4.2.3/../../../../lib/crt1.o: In function _start':
(.text+0x18): undefined reference to
main’
/tmp/ccu2JXhk.o: In function MakeBottle(double, double, double)':
MakeBottle.cxx:(.text+0x31d): undefined reference to
GC_MakeArcOfCircle::GC_MakeArcOfCircle(gp_Pnt const&, gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x32f): undefined reference to GC_MakeArcOfCircle::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x35c): undefined reference to
GC_MakeSegment::GC_MakeSegment(gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x39b): undefined reference to GC_MakeSegment::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x3ec): undefined reference to
GC_MakeSegment::GC_MakeSegment(gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x3fe): undefined reference to GC_MakeSegment::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x445): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x45d): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x4aa): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x4c2): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x50f): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x527): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x58b): undefined reference to
BRepBuilderAPI_MakeWire::BRepBuilderAPI_MakeWire(TopoDS_Edge const&, TopoDS_Edge const&, TopoDS_Edge const&)’
MakeBottle.cxx:(.text+0x5a3): undefined reference to BRepBuilderAPI_MakeWire::operator TopoDS_Wire() const'
MakeBottle.cxx:(.text+0x5e0): undefined reference to
gp::OX()’
MakeBottle.cxx:(.text+0x673): undefined reference to gp_Trsf::SetMirror(gp_Ax1 const&)'
MakeBottle.cxx:(.text+0x69d): undefined reference to
BRepBuilderAPI_Transform::BRepBuilderAPI_Transform(TopoDS_Shape const&, gp_Trsf const&, unsigned int)’
MakeBottle.cxx:(.text+0x6ab): undefined reference to BRepBuilderAPI_MakeShape::Shape() const'
MakeBottle.cxx:(.text+0x6eb): undefined reference to
BRepBuilderAPI_MakeWire::BRepBuilderAPI_MakeWire()’
MakeBottle.cxx:(.text+0x703): undefined reference to BRepBuilderAPI_MakeWire::Add(TopoDS_Wire const&)'
MakeBottle.cxx:(.text+0x71b): undefined reference to
BRepBuilderAPI_MakeWire::Add(TopoDS_Wire const&)’
MakeBottle.cxx:(.text+0x729): undefined reference to BRepBuilderAPI_MakeWire::Wire() const'
MakeBottle.cxx:(.text+0x75b): undefined reference to
BRepBuilderAPI_MakeFace::BRepBuilderAPI_MakeFace(TopoDS_Wire const&, unsigned int)’
MakeBottle.cxx:(.text+0x773): undefined reference to BRepBuilderAPI_MakeFace::operator TopoDS_Face() const'
MakeBottle.cxx:(.text+0x801): undefined reference to
BRepPrimAPI_MakePrism::BRepPrimAPI_MakePrism(TopoDS_Shape const&, gp_Vec const&, unsigned int, unsigned int)’
MakeBottle.cxx:(.text+0x819): undefined reference to BRepBuilderAPI_MakeShape::operator TopoDS_Shape() const'
MakeBottle.cxx:(.text+0x871): undefined reference to
BRepFilletAPI_MakeFillet::BRepFilletAPI_MakeFillet(TopoDS_Shape const&, ChFi3d_FilletShape)’
MakeBottle.cxx:(.text+0x899): undefined reference to TopExp_Explorer::TopExp_Explorer(TopoDS_Shape const&, TopAbs_ShapeEnum, TopAbs_ShapeEnum)'
MakeBottle.cxx:(.text+0x8ac): undefined reference to
TopExp_Explorer::Current() const’
MakeBottle.cxx:(.text+0x8f0): undefined reference to BRepFilletAPI_MakeFillet::Add(double, TopoDS_Edge const&)'
MakeBottle.cxx:(.text+0x8fe): undefined reference to
TopExp_Explorer::Next()’
MakeBottle.cxx:(.text+0x95c): undefined reference to BRepBuilderAPI_MakeShape::Shape() const'
MakeBottle.cxx:(.text+0x997): undefined reference to
gp::DZ()’
MakeBottle.cxx:(.text+0x9f0): undefined reference to gp_Ax2::gp_Ax2(gp_Pnt const&, gp_Dir const&)'
MakeBottle.cxx:(.text+0xa38): undefined reference to
BRepPrimAPI_MakeCylinder::BRepPrimAPI_MakeCylinder(gp_Ax2 const&, double, double)’
MakeBottle.cxx:(.text+0xa46): undefined reference to BRepBuilderAPI_MakeShape::Shape() const'
MakeBottle.cxx:(.text+0xa7a): undefined reference to
BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(TopoDS_Shape const&, TopoDS_Shape const&)’
MakeBottle.cxx:(.text+0xa92): undefined reference to BRepBuilderAPI_MakeShape::operator TopoDS_Shape() const'
MakeBottle.cxx:(.text+0xb22): undefined reference to
TopoDS_Face::TopoDS_Face()’
MakeBottle.cxx:(.text+0xb53): undefined reference to TopExp_Explorer::TopExp_Explorer(TopoDS_Shape const&, TopAbs_ShapeEnum, TopAbs_ShapeEnum)'
MakeBottle.cxx:(.text+0xb66): undefined reference to
TopExp_Explorer::Current() const’
MakeBottle.cxx:(.text+0xb95): undefined reference to BRep_Tool::Surface(TopoDS_Face const&)'
MakeBottle.cxx:(.text+0xb9d): undefined reference to
Geom_Plane_Type_()’
MakeBottle.cxx:(.text+0xbf0): undefined reference to Handle_Geom_Plane::DownCast(Handle_Standard_Transient const&)'
MakeBottle.cxx:(.text+0xc13): undefined reference to
Geom_ElementarySurface::Location() const’
MakeBottle.cxx:(.text+0xcf4): undefined reference to TopExp_Explorer::Next()'
MakeBottle.cxx:(.text+0xd4f): undefined reference to
TopTools_ListOfShape::TopTools_ListOfShape()’
MakeBottle.cxx:(.text+0xd64): undefined reference to TopTools_ListOfShape::Append(TopoDS_Shape const&)'
MakeBottle.cxx:(.text+0xdbf): undefined reference to
BRepOffsetAPI_MakeThickSolid::BRepOffsetAPI_MakeThickSolid(TopoDS_Shape const&, TopTools_ListOfShape const&, double, double, BRepOffset_Mode, unsigned int, unsigned int, GeomAbs_JoinType)’
MakeBottle.cxx:(.text+0xdd7): undefined reference to BRepBuilderAPI_MakeShape::operator TopoDS_Shape() const'
MakeBottle.cxx:(.text+0xeb6): undefined reference to
Geom_CylindricalSurface::Geom_CylindricalSurface(gp_Ax3 const&, double)’
MakeBottle.cxx:(.text+0xf5b): undefined reference to Geom_CylindricalSurface::Geom_CylindricalSurface(gp_Ax3 const&, double)'
MakeBottle.cxx:(.text+0xf81): undefined reference to
PI’
MakeBottle.cxx:(.text+0xfac): undefined reference to PI'
MakeBottle.cxx:(.text+0x1015): undefined reference to
PI’
MakeBottle.cxx:(.text+0x106e): undefined reference to Geom2d_Ellipse::Geom2d_Ellipse(gp_Ax2d const&, double, double, unsigned int)'
MakeBottle.cxx:(.text+0x1101): undefined reference to
Geom2d_Ellipse::Geom2d_Ellipse(gp_Ax2d const&, double, double, unsigned int)’
MakeBottle.cxx:(.text+0x1161): undefined reference to PI'
MakeBottle.cxx:(.text+0x1188): undefined reference to
Geom2d_TrimmedCurve::Geom2d_TrimmedCurve(Handle_Geom2d_Curve const&, double, double, unsigned int)’
MakeBottle.cxx:(.text+0x11e8): undefined reference to PI'
MakeBottle.cxx:(.text+0x120f): undefined reference to
Geom2d_TrimmedCurve::Geom2d_TrimmedCurve(Handle_Geom2d_Curve const&, double, double, unsigned int)’
MakeBottle.cxx:(.text+0x1247): undefined reference to Geom2d_Curve::Value(double) const'
MakeBottle.cxx:(.text+0x1277): undefined reference to
PI’
MakeBottle.cxx:(.text+0x12a4): undefined reference to Geom2d_Curve::Value(double) const'
MakeBottle.cxx:(.text+0x12c9): undefined reference to
GCE2d_MakeSegment::GCE2d_MakeSegment(gp_Pnt2d const&, gp_Pnt2d const&)’
MakeBottle.cxx:(.text+0x12de): undefined reference to GCE2d_MakeSegment::operator Handle_Geom2d_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x1332): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom2d_Curve const&, Handle_Geom_Surface const&)’
MakeBottle.cxx:(.text+0x134a): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x139e): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom2d_Curve const&, Handle_Geom_Surface const&)’
MakeBottle.cxx:(.text+0x13b6): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x140a): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom2d_Curve const&, Handle_Geom_Surface const&)’
MakeBottle.cxx:(.text+0x1422): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x1476): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom2d_Curve const&, Handle_Geom_Surface const&)’
MakeBottle.cxx:(.text+0x148e): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x14e8): undefined reference to
BRepBuilderAPI_MakeWire::BRepBuilderAPI_MakeWire(TopoDS_Edge const&, TopoDS_Edge const&)’
MakeBottle.cxx:(.text+0x1500): undefined reference to BRepBuilderAPI_MakeWire::operator TopoDS_Wire() const'
MakeBottle.cxx:(.text+0x155a): undefined reference to
BRepBuilderAPI_MakeWire::BRepBuilderAPI_MakeWire(TopoDS_Edge const&, TopoDS_Edge const&)’
MakeBottle.cxx:(.text+0x1572): undefined reference to BRepBuilderAPI_MakeWire::operator TopoDS_Wire() const'
MakeBottle.cxx:(.text+0x15b8): undefined reference to
BRepLib::BuildCurves3d(TopoDS_Shape const&)’
MakeBottle.cxx:(.text+0x15c6): undefined reference to BRepLib::BuildCurves3d(TopoDS_Shape const&)'
MakeBottle.cxx:(.text+0x15ee): undefined reference to
BRepOffsetAPI_ThruSections::BRepOffsetAPI_ThruSections(unsigned int, unsigned int, double)’
MakeBottle.cxx:(.text+0x1606): undefined reference to BRepOffsetAPI_ThruSections::AddWire(TopoDS_Wire const&)'
MakeBottle.cxx:(.text+0x161e): undefined reference to
BRepOffsetAPI_ThruSections::AddWire(TopoDS_Wire const&)’
MakeBottle.cxx:(.text+0x1634): undefined reference to BRepOffsetAPI_ThruSections::CheckCompatibility(unsigned int)'
MakeBottle.cxx:(.text+0x1642): undefined reference to
BRepBuilderAPI_MakeShape::Shape() const’
MakeBottle.cxx:(.text+0x1662): undefined reference to TopoDS_Compound::TopoDS_Compound()'
MakeBottle.cxx:(.text+0x166d): undefined reference to
BRep_Builder::BRep_Builder()’
MakeBottle.cxx:(.text+0x1682): undefined reference to TopoDS_Builder::MakeCompound(TopoDS_Compound&) const'
MakeBottle.cxx:(.text+0x16a1): undefined reference to
TopoDS_Builder::Add(TopoDS_Shape&, TopoDS_Shape const&) const’
MakeBottle.cxx:(.text+0x16c0): undefined reference to TopoDS_Builder::Add(TopoDS_Shape&, TopoDS_Shape const&) const'
/tmp/ccu2JXhk.o: In function
TopoDS::Wire(TopoDS_Shape&)’:
MakeBottle.cxx:(.text._ZN6TopoDS4WireER12TopoDS_Shape[TopoDS::Wire(TopoDS_Shape&)]+0x24): undefined reference to Standard_TypeMismatch::Raise(char*)'
/tmp/ccu2JXhk.o: In function
TopoDS::Edge(TopoDS_Shape const&)’:
MakeBottle.cxx:(.text._ZN6TopoDS4EdgeERK12TopoDS_Shape[TopoDS::Edge(TopoDS_Shape const&)]+0x24): undefined reference to Standard_TypeMismatch::Raise(char*)'
/tmp/ccu2JXhk.o: In function
TopoDS::Face(TopoDS_Shape const&)’:
MakeBottle.cxx:(.text._ZN6TopoDS4FaceERK12TopoDS_Shape[TopoDS::Face(TopoDS_Shape const&)]+0x24): undefined reference to Standard_TypeMismatch::Raise(char*)'
/tmp/ccu2JXhk.o: In function
TopLoc_Location::TopLoc_Location(TopLoc_Location const&)’:
MakeBottle.cxx:(.text._ZN15TopLoc_LocationC1ERKS_[TopLoc_Location::TopLoc_Location(TopLoc_Location const&)]+0x14): undefined reference to TopLoc_SListOfItemLocation::TopLoc_SListOfItemLocation(TopLoc_SListOfItemLocation const&)'
/tmp/ccu2JXhk.o: In function
Handle_Standard_Transient::~Handle_Standard_Transient()’:
MakeBottle.cxx:(.text._ZN25Handle_Standard_TransientD2Ev[Handle_Standard_Transient::~Handle_Standard_Transient()]+0xd): undefined reference to Handle_Standard_Transient::EndScope()'
/tmp/ccu2JXhk.o: In function
BRepLib_Command::operator delete(void*)’:
MakeBottle.cxx:(.text._ZN15BRepLib_CommanddlEPv[BRepLib_Command::operator delete(void*)]+0x14): undefined reference to Standard::Free(void*&)'
/tmp/ccu2JXhk.o: In function
BRepLib_Command::~BRepLib_Command()’:
MakeBottle.cxx:(.text._ZN15BRepLib_CommandD2Ev[BRepLib_Command::~BRepLib_Command()]+0x7): undefined reference to vtable for BRepLib_Command'
MakeBottle.cxx:(.text._ZN15BRepLib_CommandD2Ev[BRepLib_Command::~BRepLib_Command()]+0x17): undefined reference to
BRepLib_Command::Delete()’
/tmp/ccu2JXhk.o: In function BRepLib_MakeShape::operator delete(void*)':
MakeBottle.cxx:(.text._ZN17BRepLib_MakeShapedlEPv[BRepLib_MakeShape::operator delete(void*)]+0x14): undefined reference to
Standard::Free(void*&)’
/tmp/ccu2JXhk.o: In function BRepLib_MakeFace::operator delete(void*)':
MakeBottle.cxx:(.text._ZN16BRepLib_MakeFacedlEPv[BRepLib_MakeFace::operator delete(void*)]+0x14): undefined reference to
Standard::Free(void*&)’
/tmp/ccu2JXhk.o: In function BRepBuilderAPI_Command::operator delete(void*)':
MakeBottle.cxx:(.text._ZN22BRepBuilderAPI_CommanddlEPv[BRepBuilderAPI_Command::operator delete(void*)]+0x14): undefined reference to
Standard::Free(void*&)’
/tmp/ccu2JXhk.o: In function BRepBuilderAPI_MakeShape::operator delete(void*)':
MakeBottle.cxx:(.text._ZN24BRepBuilderAPI_MakeShapedlEPv[BRepBuilderAPI_MakeShape::operator delete(void*)]+0x14): undefined reference to
Standard::Free(void*&)’
/tmp/ccu2JXhk.o: In function BRepBuilderAPI_MakeFace::operator delete(void*)':
MakeBottle.cxx:(.text._ZN23BRepBuilderAPI_MakeFacedlEPv[BRepBuilderAPI_MakeFace::operator delete(void*)]+0x14): undefined reference to
Standard::Free(void*&)’
/tmp/ccu2JXhk.o:MakeBottle.cxx:(.text._ZN31BRepSweep_NumLinearRegularSweepdlEPv[BRepSweep_NumLinearRegularSweep::operator delete(void*)]+0x14): more undefined references to Standard::Free(void*&)' follow
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_Command::~BRepBuilderAPI_Command()’:
MakeBottle.cxx:(.text._ZN22BRepBuilderAPI_CommandD2Ev[BRepBuilderAPI_Command::~BRepBuilderAPI_Command()]+0x7): undefined reference to vtable for BRepBuilderAPI_Command'
MakeBottle.cxx:(.text._ZN22BRepBuilderAPI_CommandD2Ev[BRepBuilderAPI_Command::~BRepBuilderAPI_Command()]+0x17): undefined reference to
BRepBuilderAPI_Command::Delete()’
/tmp/ccu2JXhk.o: In function TopLoc_SListOfItemLocation::~TopLoc_SListOfItemLocation()':
MakeBottle.cxx:(.text._ZN26TopLoc_SListOfItemLocationD1Ev[TopLoc_SListOfItemLocation::~TopLoc_SListOfItemLocation()]+0xe): undefined reference to
TopLoc_SListOfItemLocation::Clear()’
/tmp/ccu2JXhk.o: In function TColStd_Array2OfBoolean::~TColStd_Array2OfBoolean()':
MakeBottle.cxx:(.text._ZN23TColStd_Array2OfBooleanD1Ev[TColStd_Array2OfBoolean::~TColStd_Array2OfBoolean()]+0xd): undefined reference to
TColStd_Array2OfBoolean::Destroy()’
/tmp/ccu2JXhk.o: In function BRepSweep_Array2OfShapesOfNumLinearRegularSweep::~BRepSweep_Array2OfShapesOfNumLinearRegularSweep()':
MakeBottle.cxx:(.text._ZN47BRepSweep_Array2OfShapesOfNumLinearRegularSweepD1Ev[BRepSweep_Array2OfShapesOfNumLinearRegularSweep::~BRepSweep_Array2OfShapesOfNumLinearRegularSweep()]+0xd): undefined reference to
BRepSweep_Array2OfShapesOfNumLinearRegularSweep::Destroy()’
/tmp/ccu2JXhk.o: In function TopTools_IndexedMapOfShape::~TopTools_IndexedMapOfShape()':
MakeBottle.cxx:(.text._ZN26TopTools_IndexedMapOfShapeD1Ev[TopTools_IndexedMapOfShape::~TopTools_IndexedMapOfShape()]+0xd): undefined reference to
TopTools_IndexedMapOfShape::Clear()’
/tmp/ccu2JXhk.o: In function BRepSweep_NumLinearRegularSweep::~BRepSweep_NumLinearRegularSweep()':
MakeBottle.cxx:(.text._ZN31BRepSweep_NumLinearRegularSweepD2Ev[BRepSweep_NumLinearRegularSweep::~BRepSweep_NumLinearRegularSweep()]+0x8): undefined reference to
vtable for BRepSweep_NumLinearRegularSweep’
MakeBottle.cxx:(.text._ZN31BRepSweep_NumLinearRegularSweepD2Ev[BRepSweep_NumLinearRegularSweep::~BRepSweep_NumLinearRegularSweep()]+0x18): undefined reference to BRepSweep_NumLinearRegularSweep::Delete()'
/tmp/ccu2JXhk.o: In function
BRepSweep_Trsf::~BRepSweep_Trsf()’:
MakeBottle.cxx:(.text._ZN14BRepSweep_TrsfD2Ev[BRepSweep_Trsf::~BRepSweep_Trsf()]+0x8): undefined reference to vtable for BRepSweep_Trsf'
MakeBottle.cxx:(.text._ZN14BRepSweep_TrsfD2Ev[BRepSweep_Trsf::~BRepSweep_Trsf()]+0x18): undefined reference to
BRepSweep_Trsf::Delete()’
/tmp/ccu2JXhk.o: In function BRepSweep_Translation::~BRepSweep_Translation()':
MakeBottle.cxx:(.text._ZN21BRepSweep_TranslationD1Ev[BRepSweep_Translation::~BRepSweep_Translation()]+0x8): undefined reference to
vtable for BRepSweep_Translation’
MakeBottle.cxx:(.text._ZN21BRepSweep_TranslationD1Ev[BRepSweep_Translation::~BRepSweep_Translation()]+0x18): undefined reference to BRepSweep_Translation::Delete()'
/tmp/ccu2JXhk.o: In function
Handle_TopoDS_TShape::operator=(Handle_TopoDS_TShape const&)’:
MakeBottle.cxx:(.text._ZN20Handle_TopoDS_TShapeaSERKS_[Handle_TopoDS_TShape::operator=(Handle_TopoDS_TShape const&)]+0x1c): undefined reference to Handle_Standard_Transient::Assign(Standard_Transient const*)'
/tmp/ccu2JXhk.o: In function
TopLoc_SListOfItemLocation::operator=(TopLoc_SListOfItemLocation const&)’:
MakeBottle.cxx:(.text._ZN26TopLoc_SListOfItemLocationaSERKS_[TopLoc_SListOfItemLocation::operator=(TopLoc_SListOfItemLocation const&)]+0x14): undefined reference to TopLoc_SListOfItemLocation::Assign(TopLoc_SListOfItemLocation const&)'
/tmp/ccu2JXhk.o: In function
TopTools_DataMapOfShapeShape::~TopTools_DataMapOfShapeShape()’:
MakeBottle.cxx:(.text._ZN28TopTools_DataMapOfShapeShapeD1Ev[TopTools_DataMapOfShapeShape::~TopTools_DataMapOfShapeShape()]+0xd): undefined reference to TopTools_DataMapOfShapeShape::Clear()'
/tmp/ccu2JXhk.o: In function
TopTools_DataMapOfShapeListOfShape::~TopTools_DataMapOfShapeListOfShape()’:
MakeBottle.cxx:(.text._ZN34TopTools_DataMapOfShapeListOfShapeD1Ev[TopTools_DataMapOfShapeListOfShape::~TopTools_DataMapOfShapeListOfShape()]+0xd): undefined reference to TopTools_DataMapOfShapeListOfShape::Clear()'
/tmp/ccu2JXhk.o: In function
TopTools_IndexedDataMapOfShapeListOfShape::~TopTools_IndexedDataMapOfShapeListOfShape()’:
MakeBottle.cxx:(.text._ZN41TopTools_IndexedDataMapOfShapeListOfShapeD1Ev[TopTools_IndexedDataMapOfShapeListOfShape::~TopTools_IndexedDataMapOfShapeListOfShape()]+0xd): undefined reference to TopTools_IndexedDataMapOfShapeListOfShape::Clear()'
/tmp/ccu2JXhk.o: In function
BRepOffset_DataMapOfShapeListOfInterval::~BRepOffset_DataMapOfShapeListOfInterval()’:
MakeBottle.cxx:(.text._ZN39BRepOffset_DataMapOfShapeListOfIntervalD1Ev[BRepOffset_DataMapOfShapeListOfInterval::~BRepOffset_DataMapOfShapeListOfInterval()]+0xd): undefined reference to BRepOffset_DataMapOfShapeListOfInterval::Clear()'
/tmp/ccu2JXhk.o: In function
TopTools_MapOfShape::~TopTools_MapOfShape()’:
MakeBottle.cxx:(.text._ZN19TopTools_MapOfShapeD1Ev[TopTools_MapOfShape::~TopTools_MapOfShape()]+0xd): undefined reference to TopTools_MapOfShape::Clear()'
/tmp/ccu2JXhk.o: In function
BRepOffset_DataMapOfShapeReal::~BRepOffset_DataMapOfShapeReal()’:
MakeBottle.cxx:(.text._ZN29BRepOffset_DataMapOfShapeRealD1Ev[BRepOffset_DataMapOfShapeReal::~BRepOffset_DataMapOfShapeReal()]+0xd): undefined reference to BRepOffset_DataMapOfShapeReal::Clear()'
/tmp/ccu2JXhk.o: In function
gp_Dir2d::gp_Dir2d(double, double)’:
MakeBottle.cxx:(.text._ZN8gp_Dir2dC1Edd[gp_Dir2d::gp_Dir2d(double, double)]+0x80): undefined reference to Standard_ConstructionError::Raise(char*)'
/tmp/ccu2JXhk.o: In function
Standard_Transient::operator new(unsigned int)’:
MakeBottle.cxx:(.text._ZN18Standard_TransientnwEj[Standard_Transient::operator new(unsigned int)]+0xd): undefined reference to Standard::Allocate(unsigned int)'
/tmp/ccu2JXhk.o: In function
TopTools_SequenceOfShape::~TopTools_SequenceOfShape()’:
MakeBottle.cxx:(.text._ZN24TopTools_SequenceOfShapeD1Ev[TopTools_SequenceOfShape::~TopTools_SequenceOfShape()]+0xd): undefined reference to TopTools_SequenceOfShape::Clear()'
/tmp/ccu2JXhk.o: In function
TopTools_ListOfShape::~TopTools_ListOfShape()’:
MakeBottle.cxx:(.text._ZN20TopTools_ListOfShapeD1Ev[TopTools_ListOfShape::~TopTools_ListOfShape()]+0xd): undefined reference to TopTools_ListOfShape::Clear()'
/tmp/ccu2JXhk.o: In function
BRepLib_MakeShape::~BRepLib_MakeShape()’:
MakeBottle.cxx:(.text._ZN17BRepLib_MakeShapeD2Ev[BRepLib_MakeShape::~BRepLib_MakeShape()]+0x8): undefined reference to vtable for BRepLib_MakeShape'
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_MakeShape::~BRepBuilderAPI_MakeShape()’:
MakeBottle.cxx:(.text._ZN24BRepBuilderAPI_MakeShapeD2Ev[BRepBuilderAPI_MakeShape::~BRepBuilderAPI_MakeShape()]+0x8): undefined reference to vtable for BRepBuilderAPI_MakeShape'
MakeBottle.cxx:(.text._ZN24BRepBuilderAPI_MakeShapeD2Ev[BRepBuilderAPI_MakeShape::~BRepBuilderAPI_MakeShape()]+0x18): undefined reference to
BRepBuilderAPI_MakeShape::Delete()’
/tmp/ccu2JXhk.o: In function BRepBuilderAPI_MakeFace::~BRepBuilderAPI_MakeFace()':
MakeBottle.cxx:(.text._ZN23BRepBuilderAPI_MakeFaceD1Ev[BRepBuilderAPI_MakeFace::~BRepBuilderAPI_MakeFace()]+0x8): undefined reference to
vtable for BRepBuilderAPI_MakeFace’
/tmp/ccu2JXhk.o: In function BRepPrimAPI_MakePrism::~BRepPrimAPI_MakePrism()':
MakeBottle.cxx:(.text._ZN21BRepPrimAPI_MakePrismD1Ev[BRepPrimAPI_MakePrism::~BRepPrimAPI_MakePrism()]+0x8): undefined reference to
vtable for BRepPrimAPI_MakePrism’
/tmp/ccu2JXhk.o: In function BRepAlgoAPI_BooleanOperation::~BRepAlgoAPI_BooleanOperation()':
MakeBottle.cxx:(.text._ZN28BRepAlgoAPI_BooleanOperationD2Ev[BRepAlgoAPI_BooleanOperation::~BRepAlgoAPI_BooleanOperation()]+0x8): undefined reference to
vtable for BRepAlgoAPI_BooleanOperation’
MakeBottle.cxx:(.text._ZN28BRepAlgoAPI_BooleanOperationD2Ev[BRepAlgoAPI_BooleanOperation::~BRepAlgoAPI_BooleanOperation()]+0x18): undefined reference to BRepAlgoAPI_BooleanOperation::Destroy()'
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_MakeEdge::~BRepBuilderAPI_MakeEdge()’:
MakeBottle.cxx:(.text._ZN23BRepBuilderAPI_MakeEdgeD1Ev[BRepBuilderAPI_MakeEdge::~BRepBuilderAPI_MakeEdge()]+0x8): undefined reference to vtable for BRepBuilderAPI_MakeEdge'
/tmp/ccu2JXhk.o: In function
BRepOffsetAPI_ThruSections::~BRepOffsetAPI_ThruSections()’:
MakeBottle.cxx:(.text._ZN26BRepOffsetAPI_ThruSectionsD1Ev[BRepOffsetAPI_ThruSections::~BRepOffsetAPI_ThruSections()]+0x8): undefined reference to vtable for BRepOffsetAPI_ThruSections'
/tmp/ccu2JXhk.o: In function
BRepPrimAPI_MakeOneAxis::~BRepPrimAPI_MakeOneAxis()’:
MakeBottle.cxx:(.text._ZN23BRepPrimAPI_MakeOneAxisD2Ev[BRepPrimAPI_MakeOneAxis::~BRepPrimAPI_MakeOneAxis()]+0x7): undefined reference to vtable for BRepPrimAPI_MakeOneAxis'
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_MakeWire::~BRepBuilderAPI_MakeWire()’:
MakeBottle.cxx:(.text._ZN23BRepBuilderAPI_MakeWireD1Ev[BRepBuilderAPI_MakeWire::~BRepBuilderAPI_MakeWire()]+0x8): undefined reference to vtable for BRepBuilderAPI_MakeWire'
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_ModifyShape::~BRepBuilderAPI_ModifyShape()’:
MakeBottle.cxx:(.text._ZN26BRepBuilderAPI_ModifyShapeD2Ev[BRepBuilderAPI_ModifyShape::~BRepBuilderAPI_ModifyShape()]+0x8): undefined reference to vtable for BRepBuilderAPI_ModifyShape'
/tmp/ccu2JXhk.o: In function
BRepBuilderAPI_Transform::~BRepBuilderAPI_Transform()’:
MakeBottle.cxx:(.text._ZN24BRepBuilderAPI_TransformD1Ev[BRepBuilderAPI_Transform::~BRepBuilderAPI_Transform()]+0x8): undefined reference to vtable for BRepBuilderAPI_Transform'
/tmp/ccu2JXhk.o: In function
BRepOffsetAPI_MakeOffsetShape::~BRepOffsetAPI_MakeOffsetShape()’:
MakeBottle.cxx:(.text._ZN29BRepOffsetAPI_MakeOffsetShapeD2Ev[BRepOffsetAPI_MakeOffsetShape::~BRepOffsetAPI_MakeOffsetShape()]+0x8): undefined reference to vtable for BRepOffsetAPI_MakeOffsetShape'
/tmp/ccu2JXhk.o: In function
BRepOffsetAPI_MakeThickSolid::~BRepOffsetAPI_MakeThickSolid()’:
MakeBottle.cxx:(.text._ZN28BRepOffsetAPI_MakeThickSolidD1Ev[BRepOffsetAPI_MakeThickSolid::~BRepOffsetAPI_MakeThickSolid()]+0x7): undefined reference to vtable for BRepOffsetAPI_MakeThickSolid'
/tmp/ccu2JXhk.o: In function
BRepPrim_OneAxis::~BRepPrim_OneAxis()’:
MakeBottle.cxx:(.text._ZN16BRepPrim_OneAxisD2Ev[BRepPrim_OneAxis::~BRepPrim_OneAxis()]+0x8): undefined reference to vtable for BRepPrim_OneAxis'
MakeBottle.cxx:(.text._ZN16BRepPrim_OneAxisD2Ev[BRepPrim_OneAxis::~BRepPrim_OneAxis()]+0x18): undefined reference to
BRepPrim_OneAxis::Delete()’
/tmp/ccu2JXhk.o: In function BRepPrim_Revolution::~BRepPrim_Revolution()':
MakeBottle.cxx:(.text._ZN19BRepPrim_RevolutionD2Ev[BRepPrim_Revolution::~BRepPrim_Revolution()]+0x8): undefined reference to
vtable for BRepPrim_Revolution’
/tmp/ccu2JXhk.o: In function BRepPrim_Cylinder::~BRepPrim_Cylinder()':
MakeBottle.cxx:(.text._ZN17BRepPrim_CylinderD1Ev[BRepPrim_Cylinder::~BRepPrim_Cylinder()]+0x7): undefined reference to
vtable for BRepPrim_Cylinder’
/tmp/ccu2JXhk.o: In function BRepPrimAPI_MakeCylinder::~BRepPrimAPI_MakeCylinder()':
MakeBottle.cxx:(.text._ZN24BRepPrimAPI_MakeCylinderD1Ev[BRepPrimAPI_MakeCylinder::~BRepPrimAPI_MakeCylinder()]+0x8): undefined reference to
vtable for BRepPrimAPI_MakeCylinder’
/tmp/ccu2JXhk.o: In function TopExp_Explorer::~TopExp_Explorer()':
MakeBottle.cxx:(.text._ZN15TopExp_ExplorerD1Ev[TopExp_Explorer::~TopExp_Explorer()]+0xe): undefined reference to
TopExp_Explorer::Destroy()’
/tmp/ccu2JXhk.o: In function TopTools_DataMapOfShapeListOfInteger::~TopTools_DataMapOfShapeListOfInteger()':
MakeBottle.cxx:(.text._ZN36TopTools_DataMapOfShapeListOfIntegerD1Ev[TopTools_DataMapOfShapeListOfInteger::~TopTools_DataMapOfShapeListOfInteger()]+0xd): undefined reference to
TopTools_DataMapOfShapeListOfInteger::Clear()’
/tmp/ccu2JXhk.o: In function ChFiDS_Regularities::~ChFiDS_Regularities()':
MakeBottle.cxx:(.text._ZN19ChFiDS_RegularitiesD1Ev[ChFiDS_Regularities::~ChFiDS_Regularities()]+0xd): undefined reference to
ChFiDS_Regularities::Clear()’
/tmp/ccu2JXhk.o: In function ChFiDS_IndexedDataMapOfVertexListOfStripe::~ChFiDS_IndexedDataMapOfVertexListOfStripe()':
MakeBottle.cxx:(.text._ZN41ChFiDS_IndexedDataMapOfVertexListOfStripeD1Ev[ChFiDS_IndexedDataMapOfVertexListOfStripe::~ChFiDS_IndexedDataMapOfVertexListOfStripe()]+0xd): undefined reference to
ChFiDS_IndexedDataMapOfVertexListOfStripe::Clear()’
/tmp/ccu2JXhk.o: In function ChFiDS_ListOfStripe::~ChFiDS_ListOfStripe()':
MakeBottle.cxx:(.text._ZN19ChFiDS_ListOfStripeD1Ev[ChFiDS_ListOfStripe::~ChFiDS_ListOfStripe()]+0xd): undefined reference to
ChFiDS_ListOfStripe::Clear()’
/tmp/ccu2JXhk.o: In function ChFi3d_Builder::~ChFi3d_Builder()':
MakeBottle.cxx:(.text._ZN14ChFi3d_BuilderD2Ev[ChFi3d_Builder::~ChFi3d_Builder()]+0x8): undefined reference to
vtable for ChFi3d_Builder’
MakeBottle.cxx:(.text._ZN14ChFi3d_BuilderD2Ev[ChFi3d_Builder::~ChFi3d_Builder()]+0x18): undefined reference to ChFi3d_Builder::Delete()'
/tmp/ccu2JXhk.o: In function
ChFi3d_FilBuilder::~ChFi3d_FilBuilder()’:
MakeBottle.cxx:(.text._ZN17ChFi3d_FilBuilderD1Ev[ChFi3d_FilBuilder::~ChFi3d_FilBuilder()]+0x7): undefined reference to vtable for ChFi3d_FilBuilder'
/tmp/ccu2JXhk.o: In function
BRepFilletAPI_MakeFillet::~BRepFilletAPI_MakeFillet()’:
MakeBottle.cxx:(.text._ZN24BRepFilletAPI_MakeFilletD1Ev[BRepFilletAPI_MakeFillet::~BRepFilletAPI_MakeFillet()]+0x8): undefined reference to vtable for BRepFilletAPI_MakeFillet'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x8): undefined reference to
BRepLib_Command::Delete()’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x14): undefined reference to BRepLib_MakeShape::FaceStatus(TopoDS_Face const&) const'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x18): undefined reference to
BRepLib_MakeShape::HasDescendants(TopoDS_Face const&) const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x1c): undefined reference to BRepLib_MakeShape::DescendantFaces(TopoDS_Face const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x20): undefined reference to
BRepLib_MakeShape::NbSurfaces() const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x24): undefined reference to BRepLib_MakeShape::NewFaces(int)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeFace[vtable for BRepLib_MakeFace]+0x28): undefined reference to
BRepLib_MakeShape::FacesFromEdges(TopoDS_Edge const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTI16BRepLib_MakeFace[typeinfo for BRepLib_MakeFace]+0x8): undefined reference to typeinfo for BRepLib_MakeShape'
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x8): undefined reference to
BRepBuilderAPI_MakeShape::Delete()’
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x14): undefined reference to BRepBuilderAPI_Command::IsDone() const'
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x18): undefined reference to
BRepBuilderAPI_MakeShape::Build()’
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x1c): undefined reference to BRepBuilderAPI_MakeShape::Generated(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x20): undefined reference to
BRepBuilderAPI_MakeShape::Modified(TopoDS_Shape const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTV21BRepPrimAPI_MakeSweep[vtable for BRepPrimAPI_MakeSweep]+0x24): undefined reference to BRepBuilderAPI_MakeShape::IsDeleted(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTI21BRepPrimAPI_MakeSweep[typeinfo for BRepPrimAPI_MakeSweep]+0x8): undefined reference to
typeinfo for BRepBuilderAPI_MakeShape’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x8): undefined reference to BRepBuilderAPI_MakeShape::Delete()'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x14): undefined reference to
BRepBuilderAPI_Command::IsDone() const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x18): undefined reference to BRepAlgoAPI_BooleanOperation::Build()'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x1c): undefined reference to
BRepAlgoAPI_BooleanOperation::Generated(TopoDS_Shape const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x20): undefined reference to BRepAlgoAPI_BooleanOperation::Modified(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x24): undefined reference to
BRepAlgoAPI_BooleanOperation::IsDeleted(TopoDS_Shape const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x28): undefined reference to BRepAlgoAPI_BooleanOperation::Modified2(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x2c): undefined reference to
BRepAlgoAPI_BooleanOperation::HasModified() const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x30): undefined reference to BRepAlgoAPI_BooleanOperation::HasGenerated() const'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepAlgoAPI_Fuse[vtable for BRepAlgoAPI_Fuse]+0x34): undefined reference to
BRepAlgoAPI_BooleanOperation::HasDeleted() const’
/tmp/ccu2JXhk.o:(.rodata._ZTI16BRepAlgoAPI_Fuse[typeinfo for BRepAlgoAPI_Fuse]+0x8): undefined reference to typeinfo for BRepAlgoAPI_BooleanOperation'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x8): undefined reference to
BRepLib_Command::Delete()’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x14): undefined reference to BRepLib_MakeShape::FaceStatus(TopoDS_Face const&) const'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x18): undefined reference to
BRepLib_MakeShape::HasDescendants(TopoDS_Face const&) const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x1c): undefined reference to BRepLib_MakeShape::DescendantFaces(TopoDS_Face const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x20): undefined reference to
BRepLib_MakeShape::NbSurfaces() const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x24): undefined reference to BRepLib_MakeShape::NewFaces(int)'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeEdge[vtable for BRepLib_MakeEdge]+0x28): undefined reference to
BRepLib_MakeShape::FacesFromEdges(TopoDS_Edge const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTI16BRepLib_MakeEdge[typeinfo for BRepLib_MakeEdge]+0x8): undefined reference to typeinfo for BRepLib_MakeShape'
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x8): undefined reference to
BRepBuilderAPI_MakeShape::Delete()’
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x14): undefined reference to BRepBuilderAPI_Command::IsDone() const'
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x18): undefined reference to
BRepBuilderAPI_MakeShape::Build()’
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x1c): undefined reference to BRepBuilderAPI_MakeShape::Generated(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x20): undefined reference to
BRepBuilderAPI_MakeShape::Modified(TopoDS_Shape const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTV28BRepFilletAPI_LocalOperation[vtable for BRepFilletAPI_LocalOperation]+0x24): undefined reference to BRepBuilderAPI_MakeShape::IsDeleted(TopoDS_Shape const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTI28BRepFilletAPI_LocalOperation[typeinfo for BRepFilletAPI_LocalOperation]+0x8): undefined reference to
typeinfo for BRepBuilderAPI_MakeShape’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x8): undefined reference to BRepLib_Command::Delete()'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x14): undefined reference to
BRepLib_MakeShape::FaceStatus(TopoDS_Face const&) const’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x18): undefined reference to BRepLib_MakeShape::HasDescendants(TopoDS_Face const&) const'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x1c): undefined reference to
BRepLib_MakeShape::DescendantFaces(TopoDS_Face const&)’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x20): undefined reference to BRepLib_MakeShape::NbSurfaces() const'
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x24): undefined reference to
BRepLib_MakeShape::NewFaces(int)’
/tmp/ccu2JXhk.o:(.rodata._ZTV16BRepLib_MakeWire[vtable for BRepLib_MakeWire]+0x28): undefined reference to BRepLib_MakeShape::FacesFromEdges(TopoDS_Edge const&)'
/tmp/ccu2JXhk.o:(.rodata._ZTI16BRepLib_MakeWire[typeinfo for BRepLib_MakeWire]+0x8): undefined reference to
typeinfo for BRepLib_MakeShape’
collect2: ld returned 1 exit status
Posted in Uncategorized | Leave a comment

Part 3)Trying to get MakeBottle.cxx to compile.

I was asked to compile with -E to just run the preprocessor to see what happens:
Here is the output for:
” g++ -E -I /usr/include/opencascade MakeBottle.cxx 2> MakeBottle.preprocessor_4_adam”

In file included from /usr/include/opencascade/Standard_Integer.hxx:9,
from /usr/include/opencascade/Standard_Address.hxx:21,
from /usr/include/opencascade/Standard.hxx:28,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:29,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_values.h:35:2: error: #error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
In file included from /usr/include/opencascade/Standard_OStream.hxx:7,
from /usr/include/opencascade/Standard.hxx:40,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:29,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Stream.hxx:19:2: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /usr/include/opencascade/Standard_OutOfRange.hxx:33,
from /usr/include/opencascade/gp_Mat.lxx:4,
from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/Standard_SStream.hxx:23:4: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”

I also ran it as:
g++ -E -I /usr/include/opencascade MakeBottle.cxx 1> MakeBottle.preprocessor_4_adam1
Here are the results from that:

# 1 “MakeBottle.cxx”
# 1 “<built-in>”
# 1 “<command-line>”
# 1 “MakeBottle.cxx”
# 1 “/usr/include/opencascade/BRep_Tool.hxx” 1
# 26 “/usr/include/opencascade/BRep_Tool.hxx”
# 1 “/usr/include/opencascade/Standard_Boolean.hxx” 1
# 18 “/usr/include/opencascade/Standard_Boolean.hxx”
# 1 “/usr/include/opencascade/Standard_TypeDef.hxx” 1

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 152 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 3 4
typedef int ptrdiff_t;
# 214 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 3 4
typedef unsigned int size_t;
# 8 “/usr/include/opencascade/Standard_TypeDef.hxx” 2

typedef int Standard_Integer;
typedef double Standard_Real;
typedef unsigned int Standard_Boolean;
typedef float Standard_ShortReal;
typedef char Standard_Character;
typedef short Standard_ExtCharacter;
typedef unsigned char Standard_Byte;
typedef char* Standard_CString;
typedef void* Standard_Address;
typedef short* Standard_ExtString;
typedef size_t Standard_Size;

# 1 “/usr/include/opencascade/Standard_Macro.hxx” 1
# 54 “/usr/include/opencascade/Standard_Macro.hxx”
# 1 “/usr/include/opencascade/arch/Standard_Macro64.hxx” 1
# 55 “/usr/include/opencascade/Standard_Macro.hxx” 2
# 26 “/usr/include/opencascade/Standard_TypeDef.hxx” 2

class Standard_Stream;
void ShallowDump(const Standard_Boolean, Standard_Stream& );
void ShallowDump(const Standard_CString, Standard_Stream& );
void ShallowDump(const Standard_Character, Standard_Stream& );
void ShallowDump(const Standard_ExtCharacter, Standard_Stream& );
void ShallowDump(const Standard_ExtString, Standard_Stream& );
void ShallowDump(const Standard_Integer, Standard_Stream& );
void ShallowDump(const Standard_Address, Standard_Stream& );
void ShallowDump(const Standard_Real, Standard_Stream& );
void ShallowDump(const Standard_ShortReal, Standard_Stream& );
# 19 “/usr/include/opencascade/Standard_Boolean.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Boolean_Type_();
# 39 “/usr/include/opencascade/Standard_Boolean.hxx”
Standard_Boolean ShallowCopy (const Standard_Boolean);
Standard_Integer HashCode (const Standard_Boolean, const Standard_Integer);
# 49 “/usr/include/opencascade/Standard_Boolean.hxx”
inline Standard_Boolean IsEqual(const Standard_Boolean One
,const Standard_Boolean Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_Boolean One
,const Standard_Boolean Two)
{ return One == Two; }
# 27 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 1
# 29 “/usr/include/opencascade/Handle_Geom_Surface.hxx”
# 1 “/usr/include/opencascade/Standard.hxx” 1
# 28 “/usr/include/opencascade/Standard.hxx”
# 1 “/usr/include/opencascade/Standard_Address.hxx” 1
# 12 “/usr/include/opencascade/Standard_Address.hxx”
# 1 “/usr/include/string.h” 1 3 4
# 26 “/usr/include/string.h” 3 4
# 1 “/usr/include/features.h” 1 3 4
# 330 “/usr/include/features.h” 3 4
# 1 “/usr/include/sys/cdefs.h” 1 3 4
# 348 “/usr/include/sys/cdefs.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 349 “/usr/include/sys/cdefs.h” 2 3 4
# 331 “/usr/include/features.h” 2 3 4
# 354 “/usr/include/features.h” 3 4
# 1 “/usr/include/gnu/stubs.h” 1 3 4

# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 5 “/usr/include/gnu/stubs.h” 2 3 4

# 1 “/usr/include/gnu/stubs-32.h” 1 3 4
# 8 “/usr/include/gnu/stubs.h” 2 3 4
# 355 “/usr/include/features.h” 2 3 4
# 27 “/usr/include/string.h” 2 3 4

extern “C” {

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 34 “/usr/include/string.h” 2 3 4

extern void *memcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memmove (void *__dest, __const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern void *memchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern void *rawmemchr (__const void *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern void *memrchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int strcmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strcoll (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));

# 1 “/usr/include/xlocale.h” 1 3 4
# 28 “/usr/include/xlocale.h” 3 4
typedef struct __locale_struct
{

struct locale_data *__locales[13];

const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;

const char *__names[13];
} *__locale_t;
# 119 “/usr/include/string.h” 2 3 4

extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));

extern char *strdup (__const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));

extern char *strndup (__const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 165 “/usr/include/string.h” 3 4

extern char *strchr (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strchrnul (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern size_t strcspn (__const char *__s, __const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strspn (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));

extern char *__strtok_r (char *__restrict __s,
__const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strcasestr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern void *memmem (__const void *__haystack, size_t __haystacklen,
__const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));

extern void *__mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern size_t strlen (__const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern size_t strnlen (__const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strerror (int __errnum) throw ();

# 281 “/usr/include/string.h” 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));

extern char *strerror_l (int __errnum, __locale_t __l) throw ();

extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern void bcopy (__const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *index (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *rindex (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern int ffs (int __i) throw () __attribute__ ((__const__));

extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));

extern int strcasecmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strcasecmp_l (__const char *__s1, __const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));

extern char *strsep (char **__restrict __stringp,
__const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int strverscmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strsignal (int __sig) throw ();

extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *__stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));

extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
# 432 “/usr/include/string.h” 3 4
}
# 13 “/usr/include/opencascade/Standard_Address.hxx” 2
# 21 “/usr/include/opencascade/Standard_Address.hxx”
# 1 “/usr/include/opencascade/Standard_Integer.hxx” 1
# 9 “/usr/include/opencascade/Standard_Integer.hxx”
# 1 “/usr/include/opencascade/Standard_values.h” 1
# 10 “/usr/include/opencascade/Standard_Integer.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Integer_Type_();
# 27 “/usr/include/opencascade/Standard_Integer.hxx”
Standard_Integer NextPrimeForMap(const Standard_Integer anInt ) ;
long NextPrime (const long me);
Standard_Integer CharToInt (const Standard_Character me);
Standard_Integer CharToInt (const Standard_CString me);
Standard_Integer ShallowCopy (const Standard_Integer me);
# 41 “/usr/include/opencascade/Standard_Integer.hxx”
inline Standard_Integer Abs (const Standard_Integer Value)
{
if ( Value >= 0 )
return Value;
else
return -Value;
}

inline Standard_Integer HashCode(const Standard_Integer me,
const Standard_Integer Upper)
{

return ( ( me & 0x7fffffff ) % Upper) + 1;
}

inline Standard_Boolean IsEqual(const Standard_Integer One
,const Standard_Integer Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar (const Standard_Integer One,
const Standard_Integer Two)
{ return One == Two; }

inline Standard_Boolean IsEven (const Standard_Integer Value)
{ return Value % 2 == 0; }

inline Standard_Boolean IsOdd (const Standard_Integer Value)
{ return Value % 2 == 1; }

inline Standard_Integer Max (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 >= Val2)
return Val1;
else
return Val2;
}

inline Standard_Integer Min (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 <= Val2)
return Val1;
else
return Val2;
}

inline Standard_Integer Modulus (const Standard_Integer Value,
const Standard_Integer Divisor)
{ return Value % Divisor; }

inline Standard_Integer Square(const Standard_Integer Value)
{ return Value * Value; }

inline Standard_Integer IntegerFirst()
{ return INT_MIN; }

inline Standard_Integer IntegerLast()
{ return INT_MAX; }

inline Standard_Integer IntegerSize()
{ return ((CHAR_BIT * sizeof(Standard_Integer))); }
# 22 “/usr/include/opencascade/Standard_Address.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Address_Type_();

inline Standard_Address ShallowCopy (const Standard_Address Value)
{
return Value;
}

inline Standard_Integer HashCode (const Standard_Address Value,
const Standard_Integer Upper)
{
union {Standard_Address L ;
Standard_Integer I[2] ;} U ;
U.I[0] = 0 ;
U.I[1] = 0 ;
U.L = Value;
return HashCode( ( ( U.I[0] ^ U.I[1] ) & 0x7fffffff ) , Upper ) ;
}

inline Standard_Boolean IsSimilar(const Standard_Address One
,const Standard_Address Two)
{ return One == Two; }

inline Standard_Boolean IsEqual(const Standard_Address One
,const Standard_Address Two)
{ return One == Two; }
# 29 “/usr/include/opencascade/Standard.hxx” 2
# 37 “/usr/include/opencascade/Standard.hxx”
# 1 “/usr/include/opencascade/Standard_Size.hxx” 1
# 38 “/usr/include/opencascade/Standard.hxx” 2

# 1 “/usr/include/opencascade/Standard_OStream.hxx” 1

# 1 “/usr/include/opencascade/Standard_Stream.hxx” 1
# 8 “/usr/include/opencascade/Standard_OStream.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_OStream_Type_();
# 41 “/usr/include/opencascade/Standard.hxx” 2

# 1 “/usr/include/opencascade/Standard_CString.hxx” 1
# 27 “/usr/include/opencascade/Standard_CString.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_CString_Type_();

inline Standard_Integer Abs (const Standard_Integer);
inline Standard_CString ShallowCopy (const Standard_CString Value);
inline Standard_Boolean IsSimilar(const Standard_CString One
,const Standard_CString Two);
inline Standard_Boolean IsEqual(const Standard_CString One
,const Standard_CString Two);
Standard_Integer HashCode (const Standard_CString,
const Standard_Integer);
inline Standard_Integer HashCode (const Standard_CString,
const Standard_Integer,
const Standard_Integer);
inline Standard_Integer HashCode (const Standard_CString,
const Standard_Integer ,
const Standard_Integer ,
Standard_Integer& );
Standard_Integer HashCodes (const Standard_CString ,
const Standard_Integer );
inline Standard_Boolean ISEQUAL(const Standard_CString One ,
const Standard_Integer LenOne ,
const Standard_CString Two,
const Standard_Integer LenTwo );
Standard_Boolean ISSIMILAR(const Standard_CString One ,
const Standard_Integer Len ,
const Standard_CString Two );
inline Standard_Integer HASHCODE (const Standard_CString,
const Standard_Integer,
const Standard_Integer);
inline Standard_Integer HASHCODE (const Standard_CString,
const Standard_Integer,
const Standard_Integer ,
Standard_Integer& );
Standard_Integer HASHCODES (const Standard_CString,
const Standard_Integer);

inline Standard_CString ShallowCopy (const Standard_CString Value)
{
return Value;
}

inline Standard_Boolean IsSimilar(const Standard_CString One
,const Standard_CString Two)
{
return (strcmp(One,Two) == 0);
}

inline Standard_Boolean IsEqual(const Standard_CString One
,const Standard_CString Two)
{
return (One == Two);
}

inline Standard_Integer HashCode (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper ,
Standard_Integer& aHashCode )
{
aHashCode = HashCodes( Value , Len );

return HashCode( (const Standard_Integer) aHashCode , Upper ) ;
}

inline Standard_Integer HashCode (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper )
{

return HashCode( (const Standard_Integer) HashCodes( Value , Len ) , Upper ) ;
}

inline Standard_Integer HASHCODE (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper ,
Standard_Integer& aHashCode )
{
aHashCode = HASHCODES( Value , Len );

return HashCode( (const Standard_Integer) aHashCode , Upper ) ;
}

inline Standard_Integer HASHCODE (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper)
{

return HashCode( (const Standard_Integer) HASHCODES( Value , Len ) , Upper ) ;
}
# 153 “/usr/include/opencascade/Standard_CString.hxx”
inline Standard_Boolean ISEQUAL(const Standard_CString One ,
const Standard_Integer LenOne ,
const Standard_CString Two,
const Standard_Integer LenTwo )
{

if ( One == Two )
return (Standard_Boolean) 1 ;
if ( LenOne != LenTwo )
return (Standard_Boolean) 0 ;

return ISSIMILAR( One , LenOne , Two ) ;

}
# 44 “/usr/include/opencascade/Standard.hxx” 2

class Standard_ErrorHandler;
class Standard_AncestorIterator;
class Standard_Storable;
class Standard_Persistent;
class Standard_GUID;
class Standard_Transient;
class Standard_Type;
class Standard_Failure;

class Standard {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

static Standard_Address Allocate(const Standard_Size size) ;
static void Free(Standard_Address& aStorage) ;
static Standard_Address Reallocate(Standard_Address& aStorage, const Standard_Size newSize) ;
static Standard_Integer Purge() ;

protected:
# 92 “/usr/include/opencascade/Standard.hxx”
friend class Standard_ErrorHandler;
friend class Standard_AncestorIterator;
friend class Standard_Storable;
friend class Standard_Persistent;
friend class Standard_GUID;
friend class Standard_Transient;
friend class Standard_Type;
friend class Standard_Failure;

};
# 30 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Geometry.hxx” 1
# 33 “/usr/include/opencascade/Handle_Geom_Geometry.hxx”
# 1 “/usr/include/opencascade/Handle_MMgt_TShared.hxx” 1
# 33 “/usr/include/opencascade/Handle_MMgt_TShared.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 1
# 10 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
# 1 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 1

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 5 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2
# 1 “/usr/include/stdlib.h” 1 3 4
# 33 “/usr/include/stdlib.h” 3 4
# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 34 “/usr/include/stdlib.h” 2 3 4

extern “C” {

# 1 “/usr/include/bits/waitflags.h” 1 3 4
# 43 “/usr/include/stdlib.h” 2 3 4
# 1 “/usr/include/bits/waitstatus.h” 1 3 4
# 65 “/usr/include/bits/waitstatus.h” 3 4
# 1 “/usr/include/endian.h” 1 3 4
# 37 “/usr/include/endian.h” 3 4
# 1 “/usr/include/bits/endian.h” 1 3 4
# 38 “/usr/include/endian.h” 2 3 4
# 66 “/usr/include/bits/waitstatus.h” 2 3 4

union wait
{
int w_status;
struct
{

unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;

} __wait_terminated;
struct
{

unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;

} __wait_stopped;
};
# 44 “/usr/include/stdlib.h” 2 3 4
# 96 “/usr/include/stdlib.h” 3 4

typedef struct
{
int quot;
int rem;
} div_t;

typedef struct
{
long int quot;
long int rem;
} ldiv_t;

__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;

# 140 “/usr/include/stdlib.h” 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;

extern double atof (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

__extension__ extern long long int atoll (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern double strtod (__const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1))) ;

extern float strtof (__const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) ;

extern long double strtold (__const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1))) ;

extern long int strtol (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

extern unsigned long int strtoul (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern long long int strtoq (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern long long int strtoll (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

# 240 “/usr/include/stdlib.h” 3 4
extern long int strtol_l (__const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) ;

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

extern double strtod_l (__const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;

extern float strtof_l (__const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;

extern long double strtold_l (__const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;
# 311 “/usr/include/stdlib.h” 3 4
extern char *l64a (long int __n) throw () ;

extern long int a64l (__const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

# 1 “/usr/include/sys/types.h” 1 3 4
# 29 “/usr/include/sys/types.h” 3 4
extern “C” {

# 1 “/usr/include/bits/types.h” 1 3 4
# 28 “/usr/include/bits/types.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 29 “/usr/include/bits/types.h” 2 3 4

typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;

typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 131 “/usr/include/bits/types.h” 3 4
# 1 “/usr/include/bits/typesizes.h” 1 3 4
# 132 “/usr/include/bits/types.h” 2 3 4

__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;

__extension__ typedef int __clockid_t;

__extension__ typedef void * __timer_t;

__extension__ typedef long int __blksize_t;

__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;

__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;

__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;

__extension__ typedef int __ssize_t;

typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;

__extension__ typedef int __intptr_t;

__extension__ typedef unsigned int __socklen_t;
# 32 “/usr/include/sys/types.h” 2 3 4

typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;

typedef __loff_t loff_t;

typedef __ino_t ino_t;

typedef __ino64_t ino64_t;

typedef __dev_t dev_t;

typedef __gid_t gid_t;

typedef __mode_t mode_t;

typedef __nlink_t nlink_t;

typedef __uid_t uid_t;

typedef __off_t off_t;

typedef __off64_t off64_t;

typedef __pid_t pid_t;

typedef __id_t id_t;

typedef __ssize_t ssize_t;

typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;

typedef __key_t key_t;
# 133 “/usr/include/sys/types.h” 3 4
# 1 “/usr/include/time.h” 1 3 4
# 59 “/usr/include/time.h” 3 4

typedef __clock_t clock_t;

# 75 “/usr/include/time.h” 3 4

typedef __time_t time_t;

# 93 “/usr/include/time.h” 3 4
typedef __clockid_t clockid_t;
# 105 “/usr/include/time.h” 3 4
typedef __timer_t timer_t;
# 134 “/usr/include/sys/types.h” 2 3 4

typedef __useconds_t useconds_t;

typedef __suseconds_t suseconds_t;

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 148 “/usr/include/sys/types.h” 2 3 4

typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 195 “/usr/include/sys/types.h” 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));

typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 220 “/usr/include/sys/types.h” 3 4
# 1 “/usr/include/sys/select.h” 1 3 4
# 31 “/usr/include/sys/select.h” 3 4
# 1 “/usr/include/bits/select.h” 1 3 4
# 32 “/usr/include/sys/select.h” 2 3 4

# 1 “/usr/include/bits/sigset.h” 1 3 4
# 24 “/usr/include/bits/sigset.h” 3 4
typedef int __sig_atomic_t;

typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 35 “/usr/include/sys/select.h” 2 3 4

typedef __sigset_t sigset_t;

# 1 “/usr/include/time.h” 1 3 4
# 121 “/usr/include/time.h” 3 4
struct timespec
{
__time_t tv_sec;
long int tv_nsec;
};
# 45 “/usr/include/sys/select.h” 2 3 4

# 1 “/usr/include/bits/time.h” 1 3 4
# 69 “/usr/include/bits/time.h” 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 47 “/usr/include/sys/select.h” 2 3 4
# 55 “/usr/include/sys/select.h” 3 4
typedef long int __fd_mask;
# 67 “/usr/include/sys/select.h” 3 4
typedef struct
{

__fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];

} fd_set;

typedef __fd_mask fd_mask;
# 99 “/usr/include/sys/select.h” 3 4
extern “C” {
# 109 “/usr/include/sys/select.h” 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 121 “/usr/include/sys/select.h” 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);

}
# 221 “/usr/include/sys/types.h” 2 3 4

# 1 “/usr/include/sys/sysmacros.h” 1 3 4
# 30 “/usr/include/sys/sysmacros.h” 3 4
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw ();
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw ();
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw ();
# 224 “/usr/include/sys/types.h” 2 3 4

typedef __blksize_t blksize_t;

typedef __blkcnt_t blkcnt_t;

typedef __fsblkcnt_t fsblkcnt_t;

typedef __fsfilcnt_t fsfilcnt_t;
# 262 “/usr/include/sys/types.h” 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;

# 1 “/usr/include/bits/pthreadtypes.h” 1 3 4
# 23 “/usr/include/bits/pthreadtypes.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 24 “/usr/include/bits/pthreadtypes.h” 2 3 4
# 50 “/usr/include/bits/pthreadtypes.h” 3 4
typedef unsigned long int pthread_t;

typedef union
{
char __size[36];
long int __align;
} pthread_attr_t;
# 67 “/usr/include/bits/pthreadtypes.h” 3 4
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;

typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;

int __kind;

unsigned int __nusers;
__extension__ union
{
int __spins;
__pthread_slist_t __list;
};

} __data;
char __size[24];
long int __align;
} pthread_mutex_t;

typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;

typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;

typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;

typedef unsigned int pthread_key_t;

typedef int pthread_once_t;

typedef union
{
# 170 “/usr/include/bits/pthreadtypes.h” 3 4
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;

unsigned char __flags;
unsigned char __shared;
unsigned char __pad1;
unsigned char __pad2;
int __writer;
} __data;

char __size[32];
long int __align;
} pthread_rwlock_t;

typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;

typedef volatile int pthread_spinlock_t;

typedef union
{
char __size[20];
long int __align;
} pthread_barrier_t;

typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 271 “/usr/include/sys/types.h” 2 3 4

}
# 321 “/usr/include/stdlib.h” 2 3 4

extern long int random (void) throw ();

extern void srandom (unsigned int __seed) throw ();

extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));

extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));

struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};

extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();

extern int rand_r (unsigned int *__seed) throw ();

extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));

extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));

extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));

extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));

struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
unsigned long long int __a;
};

extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;

extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;

extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));

extern void free (void *__ptr) throw ();

extern void cfree (void *__ptr) throw ();

# 1 “/usr/include/alloca.h” 1 3 4
# 25 “/usr/include/alloca.h” 3 4
# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 26 “/usr/include/alloca.h” 2 3 4

extern “C” {

extern void *alloca (size_t __size) throw ();

}
# 498 “/usr/include/stdlib.h” 2 3 4

extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;

extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;

extern void abort (void) throw () __attribute__ ((__noreturn__));

extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));

extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));

extern void exit (int __status) throw () __attribute__ ((__noreturn__));

extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));

extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;

extern char *__secure_getenv (__const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;

extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));

extern int setenv (__const char *__name, __const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));

extern int unsetenv (__const char *__name) throw ();

extern int clearenv (void) throw ();
# 583 “/usr/include/stdlib.h” 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 594 “/usr/include/stdlib.h” 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 604 “/usr/include/stdlib.h” 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 614 “/usr/include/stdlib.h” 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 625 “/usr/include/stdlib.h” 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 635 “/usr/include/stdlib.h” 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;

extern int system (__const char *__command) ;

extern char *canonicalize_file_name (__const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
# 662 “/usr/include/stdlib.h” 3 4
extern char *realpath (__const char *__restrict __name,
char *__restrict __resolved) throw () ;

typedef int (*__compar_fn_t) (__const void *, __const void *);

typedef __compar_fn_t comparison_fn_t;

extern void *bsearch (__const void *__key, __const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;

extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;

__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;

extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;

__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;

# 727 “/usr/include/stdlib.h” 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;

extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;

extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;

extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;

extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int mblen (__const char *__s, size_t __n) throw () ;

extern int mbtowc (wchar_t *__restrict __pwc,
__const char *__restrict __s, size_t __n) throw () ;

extern int wctomb (char *__s, wchar_t __wchar) throw () ;

extern size_t mbstowcs (wchar_t *__restrict __pwcs,
__const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
__const wchar_t *__restrict __pwcs, size_t __n)
throw ();

extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 815 “/usr/include/stdlib.h” 3 4
extern int getsubopt (char **__restrict __optionp,
char *__const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;

extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));

extern int posix_openpt (int __oflag) ;

extern int grantpt (int __fd) throw ();

extern int unlockpt (int __fd) throw ();

extern char *ptsname (int __fd) throw () ;

extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));

extern int getpt (void);

extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
# 883 “/usr/include/stdlib.h” 3 4
}
# 6 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

class Standard_Type;
class Handle_Standard_Type;

class Handle_Standard_Transient;
class Standard_Transient;
# 23 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx”
# 1 “/usr/include/opencascade/Standard_Real.hxx” 1

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/float.h” 1 3 4
# 5 “/usr/include/opencascade/Standard_Real.hxx” 2
# 1 “/usr/include/math.h” 1 3 4
# 30 “/usr/include/math.h” 3 4
extern “C” {

# 1 “/usr/include/bits/huge_val.h” 1 3 4
# 35 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/huge_valf.h” 1 3 4
# 37 “/usr/include/math.h” 2 3 4
# 1 “/usr/include/bits/huge_vall.h” 1 3 4
# 38 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/inf.h” 1 3 4
# 41 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/nan.h” 1 3 4
# 44 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/mathdef.h” 1 3 4
# 26 “/usr/include/bits/mathdef.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 27 “/usr/include/bits/mathdef.h” 2 3 4
# 38 “/usr/include/bits/mathdef.h” 3 4
typedef long double float_t;

typedef long double double_t;
# 48 “/usr/include/math.h” 2 3 4
# 71 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();

extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();

extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();

extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();

extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();

extern double exp (double __x) throw (); extern double __exp (double __x) throw ();

extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();

extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();

extern double log (double __x) throw (); extern double __log (double __x) throw ();

extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();

extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();

extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();

extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();

extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();

extern double logb (double __x) throw (); extern double __logb (double __x) throw ();

extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();

extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();

extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();

extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();

extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();

extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();

extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));

extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));

extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));

extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();

extern int __isinf (double __value) throw () __attribute__ ((__const__));

extern int __finite (double __value) throw () __attribute__ ((__const__));

extern int isinf (double __value) throw () __attribute__ ((__const__));

extern int finite (double __value) throw () __attribute__ ((__const__));

extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();

extern double significand (double __x) throw (); extern double __significand (double __x) throw ();

extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));

extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnan (double __value) throw () __attribute__ ((__const__));

extern int isnan (double __value) throw () __attribute__ ((__const__));

extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();

extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();

extern double tgamma (double) throw (); extern double __tgamma (double) throw ();

extern double gamma (double) throw (); extern double __gamma (double) throw ();

extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();

extern double rint (double __x) throw (); extern double __rint (double __x) throw ();

extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));

extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();

extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();

extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();

extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();

extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();

extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));

extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));

extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();

extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();

extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();

extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();

extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();

extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();

extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));

extern int __signbit (double __value) throw ()
__attribute__ ((__const__));

extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();

extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 72 “/usr/include/math.h” 2 3 4
# 94 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();

extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();

extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();

extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();

extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();

extern float expf (float __x) throw (); extern float __expf (float __x) throw ();

extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();

extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();

extern float logf (float __x) throw (); extern float __logf (float __x) throw ();

extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();

extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();

extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();

extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();

extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();

extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();

extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();

extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();

extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();

extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();

extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();

extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();

extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));

extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));

extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));

extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();

extern int __isinff (float __value) throw () __attribute__ ((__const__));

extern int __finitef (float __value) throw () __attribute__ ((__const__));

extern int isinff (float __value) throw () __attribute__ ((__const__));

extern int finitef (float __value) throw () __attribute__ ((__const__));

extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();

extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();

extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnanf (float __value) throw () __attribute__ ((__const__));

extern int isnanf (float __value) throw () __attribute__ ((__const__));

extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();

extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();

extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();

extern float gammaf (float) throw (); extern float __gammaf (float) throw ();

extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();

extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();

extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));

extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();

extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();

extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();

extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();

extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();

extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));

extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));

extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();

extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();

extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();

extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();

extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();

extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();

extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));

extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));

extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();

extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 95 “/usr/include/math.h” 2 3 4
# 141 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();

extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();

extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();

extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();

extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();

extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();

extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();

extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();

extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();

extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();

extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();

extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();

extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();

extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();

extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();

extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();

extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();

extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();

extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();

extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();

extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();

extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));

extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));

extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));

extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();

extern int __isinfl (long double __value) throw () __attribute__ ((__const__));

extern int __finitel (long double __value) throw () __attribute__ ((__const__));

extern int isinfl (long double __value) throw () __attribute__ ((__const__));

extern int finitel (long double __value) throw () __attribute__ ((__const__));

extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();

extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();

extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnanl (long double __value) throw () __attribute__ ((__const__));

extern int isnanl (long double __value) throw () __attribute__ ((__const__));

extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();

extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();

extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();

extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();

extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();

extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();

extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();

extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();

extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();

extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();

extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();

extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));

extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));

extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();

extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();

extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();

extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();

extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();

extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();

extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));

extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));

extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();

extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 142 “/usr/include/math.h” 2 3 4
# 157 “/usr/include/math.h” 3 4
extern int signgam;
# 198 “/usr/include/math.h” 3 4
enum
{
FP_NAN,

FP_INFINITE,

FP_ZERO,

FP_SUBNORMAL,

FP_NORMAL

};
# 284 “/usr/include/math.h” 3 4
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;

extern _LIB_VERSION_TYPE _LIB_VERSION;
# 307 “/usr/include/math.h” 3 4
struct __exception

{
int type;
char *name;
double arg1;
double arg2;
double retval;
};

extern int matherr (struct __exception *__exc) throw ();
# 465 “/usr/include/math.h” 3 4
}
# 6 “/usr/include/opencascade/Standard_Real.hxx” 2
# 18 “/usr/include/opencascade/Standard_Real.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_Real_Type_();
# 34 “/usr/include/opencascade/Standard_Real.hxx”
extern const Standard_Real PI;
extern const Standard_Real PI180;

extern const Standard_Real Standard_PI;
extern const Standard_Real Standard_PI180;
# 53 “/usr/include/opencascade/Standard_Real.hxx”
Standard_Integer HashCode (const Standard_Real, const Standard_Integer);
Standard_Real ShallowCopy (const Standard_Real );

Standard_Real ACos (const Standard_Real );
Standard_Real ASin (const Standard_Real );
Standard_Real ATan2 (const Standard_Real , const Standard_Real );
Standard_Real NextAfter (const Standard_Real , const Standard_Real );
Standard_Real Sign (const Standard_Real , const Standard_Real );
Standard_Real ATanh (const Standard_Real );
Standard_Real ACosh (const Standard_Real );
Standard_Real Log (const Standard_Real );
Standard_Real Sqrt (const Standard_Real );

inline Standard_Real RealSmall()
{ return 2.2250738585072014e-308; }

inline Standard_Real Abs(const Standard_Real Value)
{ return fabs(Value); }

inline Standard_Boolean IsEqual (const Standard_Real Value1,
const Standard_Real Value2)
{ return Abs((Value1 – Value2)) < RealSmall(); }

inline Standard_Boolean IsSimilar(const Standard_Real One,
const Standard_Real Two)
{ return IsEqual (One,Two); }
# 109 “/usr/include/opencascade/Standard_Real.hxx”
inline Standard_Integer RealDigits()
{ return 15; }

inline Standard_Real RealEpsilon()
{ return 2.2204460492503131e-16; }

inline Standard_Real RealFirst()
{Standard_Real aValue = -1.7976931348623157e+308; return aValue; }

inline Standard_Integer RealFirst10Exp()
{ return (-307); }

inline Standard_Real RealLast()
{ return 1.7976931348623157e+308; }

inline Standard_Integer RealLast10Exp()
{ return 308; }

inline Standard_Integer RealMantissa()
{ return 53; }

inline Standard_Integer RealRadix()
{ return 2; }

inline Standard_Integer RealSize()
{ return (CHAR_BIT * sizeof(Standard_Real)); }
# 174 “/usr/include/opencascade/Standard_Real.hxx”
inline Standard_Real IntToReal(const Standard_Integer Value)
{ return Value; }

inline Standard_Real ATan(const Standard_Real Value)
{ return atan(Value); }

inline Standard_Real Ceiling (const Standard_Real Value)
{ return ceil(Value); }

inline Standard_Real Cos (const Standard_Real Value)
{ return cos(Value); }

inline Standard_Real Cosh (const Standard_Real Value)
{ return cosh(Value); }

inline Standard_Real Epsilon (const Standard_Real Value)
{
Standard_Real aEpsilon;

if (Value>=0.0){
aEpsilon = NextAfter(Value, RealLast()) – Value;
} else {
aEpsilon = Value – NextAfter(Value, RealFirst());
}
return aEpsilon;
}

inline Standard_Real Exp (const Standard_Real Value)
{ return exp(Value); }

inline Standard_Real Floor (const Standard_Real Value)
{ return floor(Value); }

inline Standard_Real IntegerPart (const Standard_Real Value)
{ return ( (Value>0) ? floor(Value) : ceil(Value) ); }

inline Standard_Real Log10 (const Standard_Real Value)
{ return log10(Value); }

inline Standard_Real Max (const Standard_Real Val1,
const Standard_Real Val2)
{
if (Val1 >= Val2) {
return Val1;
} else {
return Val2;
}
}

inline Standard_Real Min (const Standard_Real Val1,
const Standard_Real Val2)
{
if (Val1 <= Val2) {
return Val1;
} else {
return Val2;
}
}

inline Standard_Real Pow (const Standard_Real Value, const Standard_Real P)
{ return pow(Value,P); }

inline Standard_Real RealPart (const Standard_Real Value)
{ return fabs(IntegerPart(Value) – Value); }

inline Standard_Integer RealToInt (const Standard_Real Value)
{

return ( (Value>0) ? (Standard_Integer)floor(Value) : (Standard_Integer)ceil(Value) );

}

inline Standard_Real Round (const Standard_Real Value)
{ return IntegerPart(Value + (Value > 0 ? 0.5 : -0.5)); }

inline Standard_Real Sin (const Standard_Real Value)
{ return sin(Value); }

inline Standard_Real Sinh(const Standard_Real Value)
{ return sinh(Value); }

inline Standard_Real ASinh(const Standard_Real Value)
{ return asinh(Value); }

inline Standard_Real Square(const Standard_Real Value)
{ return Value * Value; }

inline Standard_Real Tan (const Standard_Real Value)
{ return tan(Value); }

inline Standard_Real Tanh (const Standard_Real Value)
{ return tanh(Value); }
# 24 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_Character.hxx” 1
# 14 “/usr/include/opencascade/Standard_Character.hxx”
# 1 “/usr/include/opencascade/Standard_ctype.hxx” 1
# 18 “/usr/include/opencascade/Standard_ctype.hxx”
# 1 “/usr/include/ctype.h” 1 3 4
# 30 “/usr/include/ctype.h” 3 4
extern “C” {
# 48 “/usr/include/ctype.h” 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 “/usr/include/ctype.h” 3 4
extern __const unsigned short int **__ctype_b_loc (void)
__attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
__attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
__attribute__ ((__const));
# 96 “/usr/include/ctype.h” 3 4

extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();

extern int tolower (int __c) throw ();

extern int toupper (int __c) throw ();

extern int isblank (int) throw ();

extern int isctype (int __c, int __mask) throw ();

extern int isascii (int __c) throw ();

extern int toascii (int __c) throw ();

extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 “/usr/include/ctype.h” 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();

extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();

extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 “/usr/include/ctype.h” 3 4
}
# 19 “/usr/include/opencascade/Standard_ctype.hxx” 2
# 15 “/usr/include/opencascade/Standard_Character.hxx” 2
# 23 “/usr/include/opencascade/Standard_Character.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_Character_Type_();

Standard_Integer HashCode(const Standard_Character, const Standard_Integer);
# 50 “/usr/include/opencascade/Standard_Character.hxx”
inline Standard_Boolean IsEqual(const Standard_Character One,
const Standard_Character Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_Character One,
const Standard_Character Two)
{ return One == Two; }
# 79 “/usr/include/opencascade/Standard_Character.hxx”
inline Standard_Boolean IsAlphabetic(const Standard_Character me)
{ return isalpha((unsigned char)me); }

inline Standard_Boolean IsDigit(const Standard_Character me)
{ return isdigit((unsigned char)me); }

inline Standard_Boolean IsXDigit(const Standard_Character me)
{ return isxdigit((unsigned char)me); }

inline Standard_Boolean IsAlphanumeric(const Standard_Character me)
{ return (IsAlphabetic(me) || IsDigit(me)) ; }

inline Standard_Boolean IsControl(const Standard_Character me)
{ return iscntrl((unsigned char)me); }

inline Standard_Boolean IsGraphic(const Standard_Character me)
{ return isgraph((unsigned char)me); }

inline Standard_Boolean IsLowerCase(const Standard_Character me)
{ return islower((unsigned char)me); }

inline Standard_Boolean IsPrintable(const Standard_Character me)
{ return isprint((unsigned char)me); }

inline Standard_Boolean IsPunctuation(const Standard_Character me)
{ return ( IsGraphic(me) && !IsAlphanumeric(me)); }

inline Standard_Boolean IsSpace(const Standard_Character me)
{ return isspace((unsigned char)me); }

inline Standard_Boolean IsUpperCase(const Standard_Character me)
{ return isupper((unsigned char)me); }

inline Standard_Character LowerCase(const Standard_Character me)
{ return tolower(me); }

inline Standard_Character UpperCase(const Standard_Character me)
{ return toupper(me); }

inline Standard_Character ShallowCopy (const Standard_Character me)
{ return me; }
# 27 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_ExtCharacter.hxx” 1
# 27 “/usr/include/opencascade/Standard_ExtCharacter.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_ExtCharacter_Type_();

Standard_Integer HashCode(const Standard_ExtCharacter, const Standard_Integer);
# 53 “/usr/include/opencascade/Standard_ExtCharacter.hxx”
inline Standard_ExtCharacter ToExtCharacter(const Standard_Character achar)
{

return ( achar & (Standard_ExtCharacter ) 0x00ff ) ;
}

inline Standard_Character ToCharacter(const Standard_ExtCharacter achar)
{

return (achar & 0x00ff) ;
}

inline Standard_Boolean IsAnAscii(const Standard_ExtCharacter achar)
{
return ( ( achar & (Standard_ExtCharacter ) 0xff00 ) == 0 ) ;
}

inline Standard_Boolean IsEqual(const Standard_ExtCharacter One,
const Standard_ExtCharacter Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_ExtCharacter One,
const Standard_ExtCharacter Two)
{ return One == Two; }

inline Standard_ExtCharacter ShallowCopy (const Standard_ExtCharacter me)
{ return me; }
# 30 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_ExtString.hxx” 1
# 16 “/usr/include/opencascade/Standard_ExtString.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_ExtString_Type_();

inline Standard_ExtString ShallowCopy (const Standard_ExtString Value)
{
return Value;
}

Standard_Integer HashCode (const Standard_ExtString, const Standard_Integer);

inline Standard_Boolean IsSimilar(const Standard_ExtString One
,const Standard_ExtString Two)
{ return One == Two; }

inline Standard_Boolean IsEqual(const Standard_ExtString One
,const Standard_ExtString Two)
{ return One == Two; }
# 36 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_Storable.hxx” 1
# 46 “/usr/include/opencascade/Standard_Storable.hxx”
Handle_Standard_Type& Standard_Storable_Type_();
# 57 “/usr/include/opencascade/Standard_Storable.hxx”
class Standard_Storable {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~Standard_Storable(){Delete();}

virtual Standard_Integer HashCode(const Standard_Integer Upper) const;

Standard_Boolean IsEqual(const Standard_Storable& Other) const;
Standard_Boolean operator ==(const Standard_Storable& Other) const
{
return IsEqual(Other);
}

Standard_Boolean IsSimilar(const Standard_Storable& Other) const;

virtual void ShallowDump(ostream& S) const;

friend Handle_Standard_Type& Standard_Storable_Type_();

protected:
# 120 “/usr/include/opencascade/Standard_Storable.hxx”
private:
# 130 “/usr/include/opencascade/Standard_Storable.hxx”
};

inline Standard_Integer HashCode(const Standard_Storable& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}

inline Standard_Boolean IsSimilar(const Standard_Storable& me,const Standard_Storable& Other) {
return me.IsSimilar(Other);
}

inline void ShallowDump(const Standard_Storable& me,ostream& S) {
me.ShallowDump(S);
}
# 42 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

Standard_Address ShallowCopy(const Standard_Address,
const Handle_Standard_Type& );

Standard_Integer HashCode(const Standard_Address,
const Standard_Integer,
const Handle_Standard_Type&);
class Standard_Stream;
void ShallowDump(const Standard_Address,
const Handle_Standard_Type&,
Standard_Stream &aOut);
# 11 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 2

# 1 “/usr/include/opencascade/Standard_Transient_proto.hxx” 1
# 16 “/usr/include/opencascade/Standard_Transient_proto.hxx”
class Handle_Standard_Transient;
class Standard_Type;
class Handle_Standard_Type;
class Standard_Type;

class Handle_Standard_Transient;
Handle_Standard_Type& Standard_Transient_Type_();

class Standard_Transient
{

friend Handle_Standard_Type& Standard_Transient_Type_();
friend class Handle_Standard_Transient;

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}

void* operator new(size_t size)
{
return Standard::Allocate(size);
}

void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

Standard_Transient() : count(0) {}

Standard_Transient(const Standard_Transient&) : count(0) {}

Standard_Transient& operator= (const Standard_Transient&) { return *this; }

virtual ~Standard_Transient();

virtual void Delete() const;

virtual Standard_Integer HashCode(const Standard_Integer Upper) const;

virtual void ShallowDump(ostream& ) const;

virtual const Handle_Standard_Type& DynamicType() const;

Standard_Boolean IsInstance(const Handle_Standard_Type& theType) const;

Standard_Boolean IsInstance(const Standard_CString& theTypeName) const;

Standard_Boolean IsKind(const Handle_Standard_Type& theType) const;

Standard_Boolean IsKind(const Standard_CString& theTypeName) const;

virtual Handle_Standard_Transient This() const;

Standard_Integer GetRefCount() const { return count; }

private:

Standard_Integer count;
};
# 14 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 2
# 30 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
class Handle_Standard_Transient;

Standard_Integer HashCode(const Handle_Standard_Transient& ,const Standard_Integer);
# 43 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
class Handle_Standard_Transient
{
public:

Handle_Standard_Transient ()
: entity(((Standard_Transient *)0xfefd0000))
{
}

Handle_Standard_Transient (const Standard_Transient *anItem)
: entity ( anItem ? (Standard_Transient*)anItem : ((Standard_Transient *)0xfefd0000) )
{
BeginScope();
}

Handle_Standard_Transient (const Handle_Standard_Transient& aTid)
: entity ( aTid.entity )
{
BeginScope();
}

~Handle_Standard_Transient()
{
EndScope();
}

Handle_Standard_Transient& operator=(const Handle_Standard_Transient& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Transient& operator=(const Standard_Transient* anItem)
{
Assign(anItem);
return *this;
}

void Nullify()
{
EndScope();
}

Standard_Boolean IsNull() const
{
return entity == ((Standard_Transient *)0xfefd0000);
}

Standard_Transient* Access()
{
return entity;
}

const Standard_Transient* Access() const
{
return entity;
}

operator Standard_Transient*()
{
return entity;
}

operator const Standard_Transient*() const
{
return entity;
}

Standard_Transient* operator->() const
{
return entity;
}

Standard_Transient& operator*()
{
return *entity;
}

const Standard_Transient& operator*() const
{
return *entity;
}

int operator==(const Handle_Standard_Transient& right) const
{
return entity == right.entity;
}

int operator==(const Standard_Transient *right) const
{
return entity == right;
}

friend int operator==(const Standard_Transient *left, const Handle_Standard_Transient& right)
{
return left == right.entity;
}

int operator!=(const Handle_Standard_Transient& right) const
{
return entity != right.entity;
}

int operator!=(const Standard_Transient *right) const
{
return entity != right;
}

friend int operator!=(const Standard_Transient *left, const Handle_Standard_Transient& right)
{
return left != right.entity;
}

static const Handle_Standard_Transient DownCast(const Handle_Standard_Transient& AnObject);

void Dump(ostream& out) const;

protected:

Standard_Transient* ControlAccess() const
{
return entity;
}

void Assign (const Standard_Transient *anItem);

private:

inline void BeginScope() const
{
if (entity != ((Standard_Transient *)0xfefd0000))
entity->count++;
}

void EndScope();

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress, size_t )
{
if (anAddress) Standard::Free(anAddress);
}

private:

Standard_Transient *entity;
};
# 34 “/usr/include/opencascade/Handle_MMgt_TShared.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class MMgt_TShared;
Handle_Standard_Type& MMgt_TShared_Type_();

class Handle_MMgt_TShared : public Handle_Standard_Transient {
public:
Handle_MMgt_TShared():Handle_Standard_Transient() {}
Handle_MMgt_TShared(const Handle_MMgt_TShared& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_MMgt_TShared(const MMgt_TShared* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_MMgt_TShared& operator=(const Handle_MMgt_TShared& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_MMgt_TShared& operator=(const MMgt_TShared* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

MMgt_TShared* operator->() const
{
return (MMgt_TShared *)ControlAccess();
}

static const Handle_MMgt_TShared DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom_Geometry.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Geom_Geometry;
Handle_Standard_Type& Geom_Geometry_Type_();

class Handle_Geom_Geometry : public Handle_MMgt_TShared {
public:
Handle_Geom_Geometry():Handle_MMgt_TShared() {}
Handle_Geom_Geometry(const Handle_Geom_Geometry& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Geom_Geometry(const Geom_Geometry* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Geom_Geometry& operator=(const Handle_Geom_Geometry& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Geometry& operator=(const Geom_Geometry* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Geometry* operator->() const
{
return (Geom_Geometry *)ControlAccess();
}

static const Handle_Geom_Geometry DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_Geometry;
class Geom_Surface;
Handle_Standard_Type& Geom_Surface_Type_();

class Handle_Geom_Surface : public Handle_Geom_Geometry {
public:
Handle_Geom_Surface():Handle_Geom_Geometry() {}
Handle_Geom_Surface(const Handle_Geom_Surface& aHandle) : Handle_Geom_Geometry(aHandle)
{
}

Handle_Geom_Surface(const Geom_Surface* anItem) : Handle_Geom_Geometry((Geom_Geometry *)anItem)
{
}

Handle_Geom_Surface& operator=(const Handle_Geom_Surface& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Surface& operator=(const Geom_Surface* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Surface* operator->() const
{
return (Geom_Surface *)ControlAccess();
}

static const Handle_Geom_Surface DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Triangulation.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Triangulation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Triangulation;
Handle_Standard_Type& Poly_Triangulation_Type_();

class Handle_Poly_Triangulation : public Handle_MMgt_TShared {
public:
Handle_Poly_Triangulation():Handle_MMgt_TShared() {}
Handle_Poly_Triangulation(const Handle_Poly_Triangulation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Triangulation(const Poly_Triangulation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Triangulation& operator=(const Handle_Poly_Triangulation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Triangulation& operator=(const Poly_Triangulation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Triangulation* operator->() const
{
return (Poly_Triangulation *)ControlAccess();
}

static const Handle_Poly_Triangulation DownCast(const Handle_Standard_Transient& AnObject);
};
# 33 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Curve.hxx” 1
# 36 “/usr/include/opencascade/Handle_Geom_Curve.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_Geometry;
class Geom_Curve;
Handle_Standard_Type& Geom_Curve_Type_();

class Handle_Geom_Curve : public Handle_Geom_Geometry {
public:
Handle_Geom_Curve():Handle_Geom_Geometry() {}
Handle_Geom_Curve(const Handle_Geom_Curve& aHandle) : Handle_Geom_Geometry(aHandle)
{
}

Handle_Geom_Curve(const Geom_Curve* anItem) : Handle_Geom_Geometry((Geom_Geometry *)anItem)
{
}

Handle_Geom_Curve& operator=(const Handle_Geom_Curve& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Curve& operator=(const Geom_Curve* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Curve* operator->() const
{
return (Geom_Curve *)ControlAccess();
}

static const Handle_Geom_Curve DownCast(const Handle_Standard_Transient& AnObject);
};
# 39 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Polygon3D.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Polygon3D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Polygon3D;
Handle_Standard_Type& Poly_Polygon3D_Type_();

class Handle_Poly_Polygon3D : public Handle_MMgt_TShared {
public:
Handle_Poly_Polygon3D():Handle_MMgt_TShared() {}
Handle_Poly_Polygon3D(const Handle_Poly_Polygon3D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Polygon3D(const Poly_Polygon3D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Polygon3D& operator=(const Handle_Poly_Polygon3D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Polygon3D& operator=(const Poly_Polygon3D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Polygon3D* operator->() const
{
return (Poly_Polygon3D *)ControlAccess();
}

static const Handle_Poly_Polygon3D DownCast(const Handle_Standard_Transient& AnObject);
};
# 42 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx” 1
# 33 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx”
# 1 “/usr/include/opencascade/Handle_Geom2d_Geometry.hxx” 1
# 36 “/usr/include/opencascade/Handle_Geom2d_Geometry.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Geom2d_Geometry;
Handle_Standard_Type& Geom2d_Geometry_Type_();

class Handle_Geom2d_Geometry : public Handle_MMgt_TShared {
public:
Handle_Geom2d_Geometry():Handle_MMgt_TShared() {}
Handle_Geom2d_Geometry(const Handle_Geom2d_Geometry& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Geom2d_Geometry(const Geom2d_Geometry* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Geom2d_Geometry& operator=(const Handle_Geom2d_Geometry& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom2d_Geometry& operator=(const Geom2d_Geometry* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom2d_Geometry* operator->() const
{
return (Geom2d_Geometry *)ControlAccess();
}

static const Handle_Geom2d_Geometry DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom2d_Geometry;
class Geom2d_Curve;
Handle_Standard_Type& Geom2d_Curve_Type_();

class Handle_Geom2d_Curve : public Handle_Geom2d_Geometry {
public:
Handle_Geom2d_Curve():Handle_Geom2d_Geometry() {}
Handle_Geom2d_Curve(const Handle_Geom2d_Curve& aHandle) : Handle_Geom2d_Geometry(aHandle)
{
}

Handle_Geom2d_Curve(const Geom2d_Curve* anItem) : Handle_Geom2d_Geometry((Geom2d_Geometry *)anItem)
{
}

Handle_Geom2d_Curve& operator=(const Handle_Geom2d_Curve& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom2d_Curve& operator=(const Geom2d_Curve* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom2d_Curve* operator->() const
{
return (Geom2d_Curve *)ControlAccess();
}

static const Handle_Geom2d_Curve DownCast(const Handle_Standard_Transient& AnObject);
};
# 45 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Polygon2D.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Polygon2D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Polygon2D;
Handle_Standard_Type& Poly_Polygon2D_Type_();

class Handle_Poly_Polygon2D : public Handle_MMgt_TShared {
public:
Handle_Poly_Polygon2D():Handle_MMgt_TShared() {}
Handle_Poly_Polygon2D(const Handle_Poly_Polygon2D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Polygon2D(const Poly_Polygon2D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Polygon2D& operator=(const Handle_Poly_Polygon2D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Polygon2D& operator=(const Poly_Polygon2D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Polygon2D* operator->() const
{
return (Poly_Polygon2D *)ControlAccess();
}

static const Handle_Poly_Polygon2D DownCast(const Handle_Standard_Transient& AnObject);
};
# 51 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_PolygonOnTriangulation.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_PolygonOnTriangulation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_PolygonOnTriangulation;
Handle_Standard_Type& Poly_PolygonOnTriangulation_Type_();

class Handle_Poly_PolygonOnTriangulation : public Handle_MMgt_TShared {
public:
Handle_Poly_PolygonOnTriangulation():Handle_MMgt_TShared() {}
Handle_Poly_PolygonOnTriangulation(const Handle_Poly_PolygonOnTriangulation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_PolygonOnTriangulation(const Poly_PolygonOnTriangulation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_PolygonOnTriangulation& operator=(const Handle_Poly_PolygonOnTriangulation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_PolygonOnTriangulation& operator=(const Poly_PolygonOnTriangulation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_PolygonOnTriangulation* operator->() const
{
return (Poly_PolygonOnTriangulation *)ControlAccess();
}

static const Handle_Poly_PolygonOnTriangulation DownCast(const Handle_Standard_Transient& AnObject);
};
# 54 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/GeomAbs_Shape.hxx” 1
# 26 “/usr/include/opencascade/GeomAbs_Shape.hxx”
enum GeomAbs_Shape {
GeomAbs_C0,
GeomAbs_G1,
GeomAbs_C1,
GeomAbs_G2,
GeomAbs_C2,
GeomAbs_C3,
GeomAbs_CN
};
# 57 “/usr/include/opencascade/BRep_Tool.hxx” 2

class Standard_NullObject;
class Standard_NoSuchObject;
class TopoDS_Shape;
class Geom_Surface;
class TopoDS_Face;
class TopLoc_Location;
class Poly_Triangulation;
class TopoDS_Edge;
class Geom_Curve;
class Poly_Polygon3D;
class Geom2d_Curve;
class Poly_Polygon2D;
class Poly_PolygonOnTriangulation;
class gp_Pnt2d;
class Bnd_Box2d;
class gp_Pnt;
class TopoDS_Vertex;
# 86 “/usr/include/opencascade/BRep_Tool.hxx”
class BRep_Tool {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

static Standard_Boolean IsClosed(const TopoDS_Shape& S) ;

static const Handle_Geom_Surface& Surface(const TopoDS_Face& F,TopLoc_Location& L) ;

static Handle_Geom_Surface Surface(const TopoDS_Face& F) ;

static const Handle_Poly_Triangulation& Triangulation(const TopoDS_Face& F,TopLoc_Location& L) ;

static Standard_Real Tolerance(const TopoDS_Face& F) ;

static Standard_Boolean NaturalRestriction(const TopoDS_Face& F) ;

static Standard_Boolean IsGeometric(const TopoDS_Edge& E) ;

static const Handle_Geom_Curve& Curve(const TopoDS_Edge& E,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static Handle_Geom_Curve Curve(const TopoDS_Edge& E,Standard_Real& First,Standard_Real& Last) ;

static const Handle_Poly_Polygon3D& Polygon3D(const TopoDS_Edge& E,TopLoc_Location& L) ;

static Handle_Geom2d_Curve CurveOnSurface(const TopoDS_Edge& E,const TopoDS_Face& F,Standard_Real& First,Standard_Real& Last) ;

static Handle_Geom2d_Curve CurveOnSurface(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void CurveOnSurface(const TopoDS_Edge& E,Handle_Geom2d_Curve& C,Handle_Geom_Surface& S,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void CurveOnSurface(const TopoDS_Edge& E,Handle_Geom2d_Curve& C,Handle_Geom_Surface& S,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last,const Standard_Integer Index) ;

static Handle_Poly_Polygon2D PolygonOnSurface(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Handle_Poly_Polygon2D PolygonOnSurface(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static void PolygonOnSurface(const TopoDS_Edge& E,Handle_Poly_Polygon2D& C,Handle_Geom_Surface& S,TopLoc_Location& L) ;

static void PolygonOnSurface(const TopoDS_Edge& E,Handle_Poly_Polygon2D& C,Handle_Geom_Surface& S,TopLoc_Location& L,const Standard_Integer Index) ;

static const Handle_Poly_PolygonOnTriangulation& PolygonOnTriangulation(const TopoDS_Edge& E,const Handle_Poly_Triangulation& T,const TopLoc_Location& L) ;

static void PolygonOnTriangulation(const TopoDS_Edge& E,Handle_Poly_PolygonOnTriangulation& P,Handle_Poly_Triangulation& T,TopLoc_Location& L) ;

static void PolygonOnTriangulation(const TopoDS_Edge& E,Handle_Poly_PolygonOnTriangulation& P,Handle_Poly_Triangulation& T,TopLoc_Location& L,const Standard_Integer Index) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const Handle_Poly_Triangulation& T) ;

static Standard_Real Tolerance(const TopoDS_Edge& E) ;

static Standard_Boolean SameParameter(const TopoDS_Edge& E) ;

static Standard_Boolean SameRange(const TopoDS_Edge& E) ;

static Standard_Boolean Degenerated(const TopoDS_Edge& E) ;

static void Range(const TopoDS_Edge& E,Standard_Real& First,Standard_Real& Last) ;

static void Range(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void Range(const TopoDS_Edge& E,const TopoDS_Face& F,Standard_Real& First,Standard_Real& Last) ;

static void UVPoints(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,gp_Pnt2d& PFirst,gp_Pnt2d& PLast) ;

static void UVPoints(const TopoDS_Edge& E,const TopoDS_Face& F,gp_Pnt2d& PFirst,gp_Pnt2d& PLast) ;

static void SetUVPoints(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,const gp_Pnt2d& PFirst,const gp_Pnt2d& PLast) ;

static void SetUVPoints(const TopoDS_Edge& E,const TopoDS_Face& F,const gp_Pnt2d& PFirst,const gp_Pnt2d& PLast) ;

static const Bnd_Box2d& UVBox(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static const Bnd_Box2d& UVBox(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Bnd_Box2d& ChangeUVBox(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static Bnd_Box2d& ChangeUVBox(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Boolean HasContinuity(const TopoDS_Edge& E,const TopoDS_Face& F1,const TopoDS_Face& F2) ;

static GeomAbs_Shape Continuity(const TopoDS_Edge& E,const TopoDS_Face& F1,const TopoDS_Face& F2) ;

static Standard_Boolean HasContinuity(const TopoDS_Edge& E,const Handle_Geom_Surface& S1,const Handle_Geom_Surface& S2,const TopLoc_Location& L1,const TopLoc_Location& L2) ;

static GeomAbs_Shape Continuity(const TopoDS_Edge& E,const Handle_Geom_Surface& S1,const Handle_Geom_Surface& S2,const TopLoc_Location& L1,const TopLoc_Location& L2) ;

static gp_Pnt Pnt(const TopoDS_Vertex& V) ;

static Standard_Real Tolerance(const TopoDS_Vertex& V) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static gp_Pnt2d Parameters(const TopoDS_Vertex& V,const TopoDS_Face& F) ;

protected:
# 323 “/usr/include/opencascade/BRep_Tool.hxx”
private:
# 333 “/usr/include/opencascade/BRep_Tool.hxx”
};
# 2 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx” 1
# 26 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
# 1 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 1
# 26 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
# 1 “/usr/include/opencascade/TopoDS_Shape.hxx” 1
# 26 “/usr/include/opencascade/TopoDS_Shape.hxx”
# 1 “/usr/include/opencascade/Handle_TopoDS_TShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopoDS_TShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopoDS_TShape;
Handle_Standard_Type& TopoDS_TShape_Type_();

class Handle_TopoDS_TShape : public Handle_MMgt_TShared {
public:
Handle_TopoDS_TShape():Handle_MMgt_TShared() {}
Handle_TopoDS_TShape(const Handle_TopoDS_TShape& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopoDS_TShape(const TopoDS_TShape* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopoDS_TShape& operator=(const Handle_TopoDS_TShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopoDS_TShape& operator=(const TopoDS_TShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopoDS_TShape* operator->() const
{
return (TopoDS_TShape *)ControlAccess();
}

static const Handle_TopoDS_TShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 27 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopLoc_Location.hxx” 1
# 26 “/usr/include/opencascade/TopLoc_Location.hxx”
# 1 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 1
# 26 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
# 1 “/usr/include/opencascade/Handle_TopLoc_SListNodeOfSListOfItemLocation.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopLoc_SListNodeOfSListOfItemLocation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopLoc_SListNodeOfSListOfItemLocation;
Handle_Standard_Type& TopLoc_SListNodeOfSListOfItemLocation_Type_();

class Handle_TopLoc_SListNodeOfSListOfItemLocation : public Handle_MMgt_TShared {
public:
Handle_TopLoc_SListNodeOfSListOfItemLocation():Handle_MMgt_TShared() {}
Handle_TopLoc_SListNodeOfSListOfItemLocation(const Handle_TopLoc_SListNodeOfSListOfItemLocation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopLoc_SListNodeOfSListOfItemLocation(const TopLoc_SListNodeOfSListOfItemLocation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopLoc_SListNodeOfSListOfItemLocation& operator=(const Handle_TopLoc_SListNodeOfSListOfItemLocation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopLoc_SListNodeOfSListOfItemLocation& operator=(const TopLoc_SListNodeOfSListOfItemLocation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopLoc_SListNodeOfSListOfItemLocation* operator->() const
{
return (TopLoc_SListNodeOfSListOfItemLocation *)ControlAccess();
}

static const Handle_TopLoc_SListNodeOfSListOfItemLocation DownCast(const Handle_Standard_Transient& AnObject);
};
# 27 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 2

class TopLoc_SListNodeOfSListOfItemLocation;
class Standard_NoSuchObject;
class TopLoc_ItemLocation;
# 44 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
class TopLoc_SListOfItemLocation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_SListOfItemLocation();

TopLoc_SListOfItemLocation(const TopLoc_ItemLocation& anItem,const TopLoc_SListOfItemLocation& aTail);

TopLoc_SListOfItemLocation(const TopLoc_SListOfItemLocation& Other);

TopLoc_SListOfItemLocation& Assign(const TopLoc_SListOfItemLocation& Other) ;
TopLoc_SListOfItemLocation& operator =(const TopLoc_SListOfItemLocation& Other)
{
return Assign(Other);
}

Standard_Boolean IsEmpty() const;

void Clear() ;
~TopLoc_SListOfItemLocation()
{
Clear();
}

const TopLoc_ItemLocation& Value() const;

TopLoc_ItemLocation& ChangeValue() ;

void SetValue(const TopLoc_ItemLocation& anItem) ;

const TopLoc_SListOfItemLocation& Tail() const;

TopLoc_SListOfItemLocation& ChangeTail() ;

void SetTail(const TopLoc_SListOfItemLocation& aList) ;

void Construct(const TopLoc_ItemLocation& anItem) ;

TopLoc_SListOfItemLocation Constructed(const TopLoc_ItemLocation& anItem) const;

void ToTail() ;

void Initialize(const TopLoc_SListOfItemLocation& aList) ;

Standard_Boolean More() const;

void Next() ;

protected:
# 134 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
private:

Handle_TopLoc_SListNodeOfSListOfItemLocation myNode;

};
# 156 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
# 1 “/usr/include/opencascade/TCollection_SList.lxx” 1
# 12 “/usr/include/opencascade/TCollection_SList.lxx”
inline Standard_Boolean TopLoc_SListOfItemLocation::IsEmpty() const
{
return myNode.IsNull();
}
# 27 “/usr/include/opencascade/TCollection_SList.lxx”
inline void TopLoc_SListOfItemLocation::Construct(const TopLoc_ItemLocation& anItem)
{
Assign(TopLoc_SListOfItemLocation(anItem,*this));
}

inline TopLoc_SListOfItemLocation TopLoc_SListOfItemLocation::Constructed(const TopLoc_ItemLocation& anItem) const
{
return TopLoc_SListOfItemLocation(anItem,*this);
}

inline void TopLoc_SListOfItemLocation::ToTail()
{
Assign(Tail());
}

inline void TopLoc_SListOfItemLocation::Initialize(const TopLoc_SListOfItemLocation& aList)
{
Assign(aList);
}

inline Standard_Boolean TopLoc_SListOfItemLocation::More() const
{
return !IsEmpty();
}

inline void TopLoc_SListOfItemLocation::Next()
{
ToTail();
}
# 157 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 2
# 27 “/usr/include/opencascade/TopLoc_Location.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopLoc_Datum3D.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopLoc_Datum3D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopLoc_Datum3D;
Handle_Standard_Type& TopLoc_Datum3D_Type_();

class Handle_TopLoc_Datum3D : public Handle_MMgt_TShared {
public:
Handle_TopLoc_Datum3D():Handle_MMgt_TShared() {}
Handle_TopLoc_Datum3D(const Handle_TopLoc_Datum3D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopLoc_Datum3D(const TopLoc_Datum3D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopLoc_Datum3D& operator=(const Handle_TopLoc_Datum3D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopLoc_Datum3D& operator=(const TopLoc_Datum3D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopLoc_Datum3D* operator->() const
{
return (TopLoc_Datum3D *)ControlAccess();
}

static const Handle_TopLoc_Datum3D DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopLoc_Location.hxx” 2
# 40 “/usr/include/opencascade/TopLoc_Location.hxx”
class Standard_NoSuchObject;
class Standard_ConstructionError;
class gp_Trsf;
class TopLoc_Datum3D;
# 57 “/usr/include/opencascade/TopLoc_Location.hxx”
class TopLoc_Location {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_Location();

TopLoc_Location(const gp_Trsf& T);

TopLoc_Location(const Handle_TopLoc_Datum3D& D);

Standard_Boolean IsIdentity() const;

void Identity() ;

const Handle_TopLoc_Datum3D& FirstDatum() const;

Standard_Integer FirstPower() const;

const TopLoc_Location& NextLocation() const;

const gp_Trsf& Transformation() const;
operator gp_Trsf() const;

TopLoc_Location Inverted() const;

TopLoc_Location Multiplied(const TopLoc_Location& Other) const;
TopLoc_Location operator*(const TopLoc_Location& Other) const
{
return Multiplied(Other);
}

TopLoc_Location Divided(const TopLoc_Location& Other) const;
TopLoc_Location operator/(const TopLoc_Location& Other) const
{
return Divided(Other);
}

TopLoc_Location Predivided(const TopLoc_Location& Other) const;

TopLoc_Location Powered(const Standard_Integer pwr) const;

Standard_Integer HashCode(const Standard_Integer Upper) const;

Standard_Boolean IsEqual(const TopLoc_Location& Other) const;
Standard_Boolean operator ==(const TopLoc_Location& Other) const
{
return IsEqual(Other);
}

Standard_Boolean IsDifferent(const TopLoc_Location& Other) const;
Standard_Boolean operator !=(const TopLoc_Location& Other) const
{
return IsDifferent(Other);
}

void ShallowDump(ostream& S) const;

protected:
# 194 “/usr/include/opencascade/TopLoc_Location.hxx”
private:

TopLoc_SListOfItemLocation myItems;

};

# 1 “/usr/include/opencascade/TopLoc_Location.lxx” 1

# 1 “/usr/include/opencascade/TopLoc_ItemLocation.hxx” 1
# 32 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
# 1 “/usr/include/opencascade/TopLoc_TrsfPtr.hxx” 1
# 25 “/usr/include/opencascade/TopLoc_TrsfPtr.hxx”
class gp_Trsf;

typedef gp_Trsf* TopLoc_TrsfPtr;
# 33 “/usr/include/opencascade/TopLoc_ItemLocation.hxx” 2

class TopLoc_Datum3D;
class TopLoc_Location;
# 59 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
class TopLoc_ItemLocation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_ItemLocation(const Handle_TopLoc_Datum3D& D,const Standard_Integer P,const Standard_Boolean fromTrsf = (Standard_Boolean) 0);

TopLoc_ItemLocation(const TopLoc_ItemLocation& anOther);

TopLoc_ItemLocation& Assign(const TopLoc_ItemLocation& anOther) ;
TopLoc_ItemLocation& operator=(const TopLoc_ItemLocation& anOther)
{
return Assign(anOther);
}

void Destroy() ;
~TopLoc_ItemLocation()
{
Destroy();
}

friend class TopLoc_Location;

protected:
# 116 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
private:

Handle_TopLoc_Datum3D myDatum;
Standard_Integer myPower;
TopLoc_TrsfPtr myTrsf;

};
# 9 “/usr/include/opencascade/TopLoc_Location.lxx” 2

inline Standard_Boolean TopLoc_Location::IsIdentity() const
{
return myItems.IsEmpty();
}

inline void TopLoc_Location::Identity()
{
myItems.Clear();
}

inline const Handle_TopLoc_Datum3D& TopLoc_Location::FirstDatum()const
{
return myItems.Value().myDatum;
}

inline Standard_Integer TopLoc_Location::FirstPower()const
{
return myItems.Value().myPower;
}

inline const TopLoc_Location& TopLoc_Location::NextLocation()const
{
return (*(TopLoc_Location*) &(myItems.Tail()));
}
# 209 “/usr/include/opencascade/TopLoc_Location.hxx” 2

inline Standard_Integer HashCode(const TopLoc_Location& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}

inline void ShallowDump(const TopLoc_Location& me,ostream& S) {
me.ShallowDump(S);
}
# 30 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopAbs_Orientation.hxx” 1
# 45 “/usr/include/opencascade/TopAbs_Orientation.hxx”
enum TopAbs_Orientation {
TopAbs_FORWARD,
TopAbs_REVERSED,
TopAbs_INTERNAL,
TopAbs_EXTERNAL
};
# 33 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopAbs_ShapeEnum.hxx” 1
# 65 “/usr/include/opencascade/TopAbs_ShapeEnum.hxx”
enum TopAbs_ShapeEnum {
TopAbs_COMPOUND,
TopAbs_COMPSOLID,
TopAbs_SOLID,
TopAbs_SHELL,
TopAbs_FACE,
TopAbs_WIRE,
TopAbs_EDGE,
TopAbs_VERTEX,
TopAbs_SHAPE
};
# 39 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

class TopoDS_TShape;
class Standard_NullObject;
class Standard_DomainError;
class Standard_TypeMismatch;
class TopLoc_Location;
# 67 “/usr/include/opencascade/TopoDS_Shape.hxx”
class TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Shape();

Standard_Boolean IsNull() const;

void Nullify() ;

const TopLoc_Location& Location() const;

void Location(const TopLoc_Location& Loc) ;

TopoDS_Shape Located(const TopLoc_Location& Loc) const;

TopAbs_Orientation Orientation() const;

void Orientation(const TopAbs_Orientation Orient) ;

TopoDS_Shape Oriented(const TopAbs_Orientation Or) const;

const Handle_TopoDS_TShape& TShape() const;

TopAbs_ShapeEnum ShapeType() const;

Standard_Boolean Free() const;

void Free(const Standard_Boolean F) ;

Standard_Boolean Modified() const;

void Modified(const Standard_Boolean M) ;

Standard_Boolean Checked() const;

void Checked(const Standard_Boolean C) ;

Standard_Boolean Orientable() const;

void Orientable(const Standard_Boolean C) ;

Standard_Boolean Closed() const;

void Closed(const Standard_Boolean C) ;

Standard_Boolean Infinite() const;

void Infinite(const Standard_Boolean C) ;

Standard_Boolean Convex() const;

void Convex(const Standard_Boolean C) ;

void Move(const TopLoc_Location& position) ;

TopoDS_Shape Moved(const TopLoc_Location& position) const;

void Reverse() ;

TopoDS_Shape Reversed() const;

void Complement() ;

TopoDS_Shape Complemented() const;

void Compose(const TopAbs_Orientation Orient) ;

TopoDS_Shape Composed(const TopAbs_Orientation Orient) const;

Standard_Boolean IsPartner(const TopoDS_Shape& other) const;

Standard_Boolean IsSame(const TopoDS_Shape& other) const;

Standard_Boolean IsEqual(const TopoDS_Shape& other) const;
Standard_Boolean operator ==(const TopoDS_Shape& other) const
{
return IsEqual(other);
}

Standard_Boolean IsNotEqual(const TopoDS_Shape& other) const;
Standard_Boolean operator !=(const TopoDS_Shape& other) const
{
return IsNotEqual(other);
}

Standard_Integer HashCode(const Standard_Integer Upper) const;

void EmptyCopy() ;

TopoDS_Shape EmptyCopied() const;

void TShape(const Handle_TopoDS_TShape& T) ;

protected:
# 261 “/usr/include/opencascade/TopoDS_Shape.hxx”
private:

Handle_TopoDS_TShape myTShape;
TopLoc_Location myLocation;
TopAbs_Orientation myOrient;

};

# 1 “/usr/include/opencascade/TopoDS_Shape.lxx” 1

# 1 “/usr/include/opencascade/TopoDS_TShape.hxx” 1
# 34 “/usr/include/opencascade/TopoDS_TShape.hxx”
# 1 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx” 1
# 33 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TCollection_MapNode.hxx” 1
# 36 “/usr/include/opencascade/Handle_TCollection_MapNode.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TCollection_MapNode;
Handle_Standard_Type& TCollection_MapNode_Type_();

class Handle_TCollection_MapNode : public Handle_MMgt_TShared {
public:
Handle_TCollection_MapNode():Handle_MMgt_TShared() {}
Handle_TCollection_MapNode(const Handle_TCollection_MapNode& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TCollection_MapNode(const TCollection_MapNode* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TCollection_MapNode& operator=(const Handle_TCollection_MapNode& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TCollection_MapNode& operator=(const TCollection_MapNode* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TCollection_MapNode* operator->() const
{
return (TCollection_MapNode *)ControlAccess();
}

static const Handle_TCollection_MapNode DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopoDS_ListNodeOfListOfShape;
Handle_Standard_Type& TopoDS_ListNodeOfListOfShape_Type_();

class Handle_TopoDS_ListNodeOfListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopoDS_ListNodeOfListOfShape():Handle_TCollection_MapNode() {}
Handle_TopoDS_ListNodeOfListOfShape(const Handle_TopoDS_ListNodeOfListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopoDS_ListNodeOfListOfShape(const TopoDS_ListNodeOfListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopoDS_ListNodeOfListOfShape& operator=(const Handle_TopoDS_ListNodeOfListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopoDS_ListNodeOfListOfShape& operator=(const TopoDS_ListNodeOfListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopoDS_ListNodeOfListOfShape* operator->() const
{
return (TopoDS_ListNodeOfListOfShape *)ControlAccess();
}

static const Handle_TopoDS_ListNodeOfListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 2

class Standard_NoSuchObject;
class TopoDS_ListIteratorOfListOfShape;
class TopoDS_Shape;
class TopoDS_ListNodeOfListOfShape;
# 51 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
class TopoDS_ListOfShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_ListOfShape();

void Assign(const TopoDS_ListOfShape& Other) ;
void operator=(const TopoDS_ListOfShape& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~TopoDS_ListOfShape()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const TopoDS_Shape& I) ;

void Prepend(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& theIt) ;

void Prepend(TopoDS_ListOfShape& Other) ;

void Append(const TopoDS_Shape& I) ;

void Append(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& theIt) ;

void Append(TopoDS_ListOfShape& Other) ;

TopoDS_Shape& First() const;

TopoDS_Shape& Last() const;

void RemoveFirst() ;

void Remove(TopoDS_ListIteratorOfListOfShape& It) ;

void InsertBefore(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertBefore(TopoDS_ListOfShape& Other,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertAfter(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertAfter(TopoDS_ListOfShape& Other,TopoDS_ListIteratorOfListOfShape& It) ;

friend class TopoDS_ListIteratorOfListOfShape;

protected:
# 151 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
private:

TopoDS_ListOfShape(const TopoDS_ListOfShape& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 179 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean TopoDS_ListOfShape::IsEmpty() const

{
return myFirst == 0L;
}
# 180 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 2
# 35 “/usr/include/opencascade/TopoDS_TShape.hxx” 2

# 1 “/usr/include/opencascade/MMgt_TShared.hxx” 1
# 34 “/usr/include/opencascade/MMgt_TShared.hxx”
# 1 “/usr/include/opencascade/Standard_Transient.hxx” 1
# 14 “/usr/include/opencascade/Standard_Transient.hxx”
# 1 “/usr/include/opencascade/Standard_Type.hxx” 1
# 30 “/usr/include/opencascade/Standard_Type.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Type.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_Type.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class Standard_Type;
Handle_Standard_Type& Standard_Type_Type_();

class Handle_Standard_Type : public Handle_Standard_Transient {
public:
Handle_Standard_Type():Handle_Standard_Transient() {}
Handle_Standard_Type(const Handle_Standard_Type& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_Standard_Type(const Standard_Type* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_Standard_Type& operator=(const Handle_Standard_Type& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Type& operator=(const Standard_Type* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_Type* operator->() const
{
return (Standard_Type *)ControlAccess();
}

static const Handle_Standard_Type DownCast(const Handle_Standard_Transient& AnObject);
};
# 31 “/usr/include/opencascade/Standard_Type.hxx” 2
# 40 “/usr/include/opencascade/Standard_Type.hxx”
# 1 “/usr/include/opencascade/Standard_KindOfType.hxx” 1
# 26 “/usr/include/opencascade/Standard_KindOfType.hxx”
enum Standard_KindOfType {
Standard_IsUnKnown,
Standard_IsClass,
Standard_IsEnumeration,
Standard_IsPrimitive,
Standard_IsImported,
Standard_IsPackage
};
# 41 “/usr/include/opencascade/Standard_Type.hxx” 2
# 54 “/usr/include/opencascade/Standard_Type.hxx”
class Standard_TypeMismatch;
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Standard_AncestorIterator;

class Standard_Type : public Standard_Transient {

public:

Standard_CString Name() const;

Standard_Integer Size() const;

Standard_Type(const Standard_CString aName,const Standard_Integer aSize);

Standard_Type(const Standard_CString aName);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfParent,const Standard_Address aAncestors);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfElement,const Standard_Integer aNumberOfParent,const Standard_Address anAncestors,const Standard_Address aElements);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfParent,const Standard_Address anAncestors,const Standard_Address aFields);

Standard_Boolean SubType(const Handle_Standard_Type& aOther) const;

Standard_Boolean SubType(const Standard_CString theName) const;

Standard_Boolean IsImported() const;

Standard_Boolean IsPrimitive() const;

Standard_Boolean IsEnumeration() const;

Standard_Boolean IsClass() const;

Standard_Integer NumberOfParent() const;

Standard_Integer NumberOfAncestor() const;

void ShallowDump() const;

void ShallowDump(ostream& S) const;
# 150 “/usr/include/opencascade/Standard_Type.hxx”
void Print(ostream& s) const;
void operator<<(ostream& s) const { Print(s); }

friend class Standard_AncestorIterator;

const Handle_Standard_Type& DynamicType() const;

protected:
# 173 “/usr/include/opencascade/Standard_Type.hxx”
private:

Standard_Address Ancestors() const;

void InLineDummy() const;

Standard_CString myName;
Standard_Integer mySize;
Standard_KindOfType myKind;
Standard_Integer myNumberOfParent;
Standard_Integer myNumberOfAncestor;
Standard_Address myAncestors;

};

# 1 “/usr/include/opencascade/Standard_Type.lxx” 1
# 9 “/usr/include/opencascade/Standard_Type.lxx”
inline void Standard_Type::InLineDummy() const
{
}

ostream& operator << (ostream& AStream
,const Handle_Standard_Type& AType);
# 202 “/usr/include/opencascade/Standard_Type.hxx” 2

inline void ShallowDump(const Handle_Standard_Type& me) {
me->ShallowDump();
}

inline void ShallowDump(const Handle_Standard_Type& me,ostream& S) {
me->ShallowDump(S);
}
# 15 “/usr/include/opencascade/Standard_Transient.hxx” 2
# 35 “/usr/include/opencascade/MMgt_TShared.hxx” 2

class Standard_OutOfMemory;
# 58 “/usr/include/opencascade/MMgt_TShared.hxx”
class MMgt_TShared : public Standard_Transient {

public:

virtual void Delete() const;

const Handle_Standard_Type& DynamicType() const;

protected:
# 86 “/usr/include/opencascade/MMgt_TShared.hxx”
private:
# 96 “/usr/include/opencascade/MMgt_TShared.hxx”
};
# 41 “/usr/include/opencascade/TopoDS_TShape.hxx” 2

class Standard_ConstructionError;
class TopoDS_Iterator;
class TopoDS_Builder;
class TopoDS_ListOfShape;
# 76 “/usr/include/opencascade/TopoDS_TShape.hxx”
class TopoDS_TShape : public MMgt_TShared {

public:

Standard_Boolean Free() const;

void Free(const Standard_Boolean F) ;

Standard_Boolean Modified() const;

void Modified(const Standard_Boolean M) ;

Standard_Boolean Checked() const;

void Checked(const Standard_Boolean C) ;

Standard_Boolean Orientable() const;

void Orientable(const Standard_Boolean C) ;

Standard_Boolean Closed() const;

void Closed(const Standard_Boolean C) ;

Standard_Boolean Infinite() const;

void Infinite(const Standard_Boolean C) ;

Standard_Boolean Convex() const;

void Convex(const Standard_Boolean C) ;

virtual TopAbs_ShapeEnum ShapeType() const = 0;

virtual Handle_TopoDS_TShape EmptyCopy() const = 0;

friend class TopoDS_Iterator;
friend class TopoDS_Builder;

const Handle_Standard_Type& DynamicType() const;

protected:
# 155 “/usr/include/opencascade/TopoDS_TShape.hxx”
TopoDS_TShape();

private:

const TopoDS_ListOfShape& Shapes() const;

TopoDS_ListOfShape& ChangeShapes() ;

TopoDS_ListOfShape myShapes;
Standard_Integer myFlags;

};

# 1 “/usr/include/opencascade/TopoDS_TShape.lxx” 1
# 11 “/usr/include/opencascade/TopoDS_TShape.lxx”
inline const TopoDS_ListOfShape& TopoDS_TShape::Shapes() const
{
return myShapes;
}

inline TopoDS_ListOfShape& TopoDS_TShape::ChangeShapes()
{
return myShapes;
}
# 182 “/usr/include/opencascade/TopoDS_TShape.hxx” 2
# 8 “/usr/include/opencascade/TopoDS_Shape.lxx” 2
# 1 “/usr/include/opencascade/TopAbs.hxx” 1
# 35 “/usr/include/opencascade/TopAbs.hxx”
# 1 “/usr/include/opencascade/TopAbs_State.hxx” 1
# 30 “/usr/include/opencascade/TopAbs_State.hxx”
enum TopAbs_State {
TopAbs_IN,
TopAbs_OUT,
TopAbs_ON,
TopAbs_UNKNOWN
};
# 36 “/usr/include/opencascade/TopAbs.hxx” 2
# 47 “/usr/include/opencascade/TopAbs.hxx”
class TopAbs {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 84 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Compose(const TopAbs_Orientation Or1,const TopAbs_Orientation Or2) ;
# 97 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Reverse(const TopAbs_Orientation Or) ;
# 113 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Complement(const TopAbs_Orientation Or) ;

static ostream& Print(const TopAbs_ShapeEnum SE,ostream& S) ;

static ostream& Print(const TopAbs_Orientation Or,ostream& S) ;

static ostream& Print(const TopAbs_State St,ostream& S) ;

protected:
# 144 “/usr/include/opencascade/TopAbs.hxx”
private:
# 154 “/usr/include/opencascade/TopAbs.hxx”
};
# 9 “/usr/include/opencascade/TopoDS_Shape.lxx” 2

inline Standard_Boolean TopoDS_Shape::IsNull () const
{
return myTShape.IsNull();
}

inline void TopoDS_Shape::Nullify ()
{
myTShape.Nullify();
}

inline const TopLoc_Location& TopoDS_Shape::Location () const
{
return myLocation;
}

inline void TopoDS_Shape::Location (const TopLoc_Location& Loc)
{
myLocation = Loc;
}

inline TopoDS_Shape TopoDS_Shape::Located(const TopLoc_Location& Loc) const
{
TopoDS_Shape S(*this);
S.Location(Loc);
return S;
}

inline TopAbs_Orientation TopoDS_Shape::Orientation () const
{
return myOrient;
}

inline void TopoDS_Shape::Orientation (const TopAbs_Orientation Orient)
{
myOrient = Orient;
}

inline TopoDS_Shape TopoDS_Shape::Oriented(const TopAbs_Orientation Or) const
{
TopoDS_Shape S(*this);
S.Orientation(Or);
return S;
}

inline const Handle_TopoDS_TShape& TopoDS_Shape::TShape () const
{
return myTShape;
}

inline TopAbs_ShapeEnum TopoDS_Shape::ShapeType() const
{
return myTShape->ShapeType();
}

inline Standard_Boolean TopoDS_Shape::Free () const
{
return myTShape->Free();
}

inline void TopoDS_Shape::Free (const Standard_Boolean B)
{
myTShape->Free(B);
}

inline Standard_Boolean TopoDS_Shape::Modified () const
{
return myTShape->Modified();
}

inline void TopoDS_Shape::Modified (const Standard_Boolean B)
{
myTShape->Modified(B);
}

inline Standard_Boolean TopoDS_Shape::Checked () const
{
return myTShape->Checked();
}

inline void TopoDS_Shape::Checked (const Standard_Boolean B)
{
myTShape->Checked(B);
}

inline Standard_Boolean TopoDS_Shape::Orientable () const
{
return myTShape->Orientable();
}

inline void TopoDS_Shape::Orientable (const Standard_Boolean B)
{
myTShape->Orientable(B);
}

inline Standard_Boolean TopoDS_Shape::Closed () const
{
return myTShape->Closed();
}

inline void TopoDS_Shape::Closed (const Standard_Boolean B)
{
myTShape->Closed(B);
}

inline Standard_Boolean TopoDS_Shape::Infinite () const
{
return myTShape->Infinite();
}

inline void TopoDS_Shape::Infinite (const Standard_Boolean B)
{
myTShape->Infinite(B);
}

inline Standard_Boolean TopoDS_Shape::Convex () const
{
return myTShape->Convex();
}

inline void TopoDS_Shape::Convex (const Standard_Boolean B)
{
myTShape->Convex(B);
}

inline void TopoDS_Shape::Move (const TopLoc_Location& position)
{
myLocation = position * myLocation;
}

inline TopoDS_Shape TopoDS_Shape::Moved
(const TopLoc_Location& position) const
{
TopoDS_Shape S(*this);
S.Move(position);
return S;
}

inline void TopoDS_Shape::Reverse()
{
myOrient = TopAbs::Reverse(myOrient);
}

inline TopoDS_Shape TopoDS_Shape::Reversed() const
{
TopoDS_Shape S(*this);
S.Reverse();
return S;
}

inline void TopoDS_Shape::Complement()
{
myOrient = TopAbs::Complement(myOrient);
}

inline TopoDS_Shape TopoDS_Shape::Complemented() const
{
TopoDS_Shape S(*this);
S.Complement();
return S;
}

inline void TopoDS_Shape::Compose(const TopAbs_Orientation Orient)
{
myOrient = TopAbs::Compose(myOrient,Orient);
}

inline TopoDS_Shape TopoDS_Shape::Composed
(const TopAbs_Orientation Orient) const
{
TopoDS_Shape S(*this);
S.Compose(Orient);
return S;
}

inline Standard_Boolean TopoDS_Shape::IsPartner
(const TopoDS_Shape& other) const
{
return myTShape == other.TShape();
}

inline void TopoDS_Shape::EmptyCopy()
{
myTShape = myTShape->EmptyCopy();
}

inline TopoDS_Shape TopoDS_Shape::EmptyCopied() const
{
TopoDS_Shape S(*this);
S.EmptyCopy();
return S;
}

inline void TopoDS_Shape::TShape (const Handle_TopoDS_TShape& TS)
{
myTShape = TS;
}
# 278 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

inline Standard_Integer HashCode(const TopoDS_Shape& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}
# 27 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOP_Operation.hxx” 1
# 26 “/usr/include/opencascade/BOP_Operation.hxx”
enum BOP_Operation {
BOP_COMMON,
BOP_FUSE,
BOP_CUT,
BOP_CUT21,
BOP_SECTION,
BOP_UNKNOWN
};
# 33 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOPTools_PDSFiller.hxx” 1
# 25 “/usr/include/opencascade/BOPTools_PDSFiller.hxx”
class BOPTools_DSFiller;

typedef BOPTools_DSFiller* BOPTools_PDSFiller;
# 39 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOP_PBuilder.hxx” 1
# 25 “/usr/include/opencascade/BOP_PBuilder.hxx”
class BOP_Builder;

typedef BOP_Builder* BOP_PBuilder;
# 42 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/Handle_BOP_HistoryCollector.hxx” 1
# 36 “/usr/include/opencascade/Handle_BOP_HistoryCollector.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class BOP_HistoryCollector;
Handle_Standard_Type& BOP_HistoryCollector_Type_();

class Handle_BOP_HistoryCollector : public Handle_MMgt_TShared {
public:
Handle_BOP_HistoryCollector():Handle_MMgt_TShared() {}
Handle_BOP_HistoryCollector(const Handle_BOP_HistoryCollector& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_BOP_HistoryCollector(const BOP_HistoryCollector* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_BOP_HistoryCollector& operator=(const Handle_BOP_HistoryCollector& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BOP_HistoryCollector& operator=(const BOP_HistoryCollector* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BOP_HistoryCollector* operator->() const
{
return (BOP_HistoryCollector *)ControlAccess();
}

static const Handle_BOP_HistoryCollector DownCast(const Handle_Standard_Transient& AnObject);
};
# 45 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 1
# 29 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
# 1 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_ListNodeOfListOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_ListNodeOfListOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_ListNodeOfListOfShape;
Handle_Standard_Type& TopTools_ListNodeOfListOfShape_Type_();

class Handle_TopTools_ListNodeOfListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_ListNodeOfListOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_ListNodeOfListOfShape(const Handle_TopTools_ListNodeOfListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_ListNodeOfListOfShape(const TopTools_ListNodeOfListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_ListNodeOfListOfShape& operator=(const Handle_TopTools_ListNodeOfListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_ListNodeOfListOfShape& operator=(const TopTools_ListNodeOfListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_ListNodeOfListOfShape* operator->() const
{
return (TopTools_ListNodeOfListOfShape *)ControlAccess();
}

static const Handle_TopTools_ListNodeOfListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 2

class Standard_NoSuchObject;
class TopTools_ListIteratorOfListOfShape;
class TopoDS_Shape;
class TopTools_ListNodeOfListOfShape;
# 51 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
class TopTools_ListOfShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_ListOfShape();

void Assign(const TopTools_ListOfShape& Other) ;
void operator=(const TopTools_ListOfShape& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~TopTools_ListOfShape()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const TopoDS_Shape& I) ;

void Prepend(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& theIt) ;

void Prepend(TopTools_ListOfShape& Other) ;

void Append(const TopoDS_Shape& I) ;

void Append(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& theIt) ;

void Append(TopTools_ListOfShape& Other) ;

TopoDS_Shape& First() const;

TopoDS_Shape& Last() const;

void RemoveFirst() ;

void Remove(TopTools_ListIteratorOfListOfShape& It) ;

void InsertBefore(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& It) ;

void InsertBefore(TopTools_ListOfShape& Other,TopTools_ListIteratorOfListOfShape& It) ;

void InsertAfter(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& It) ;

void InsertAfter(TopTools_ListOfShape& Other,TopTools_ListIteratorOfListOfShape& It) ;

friend class TopTools_ListIteratorOfListOfShape;

protected:
# 151 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
private:

TopTools_ListOfShape(const TopTools_ListOfShape& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 179 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean TopTools_ListOfShape::IsEmpty() const

{
return myFirst == 0L;
}
# 180 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 2
# 30 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx” 1
# 28 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx”
class StdFail_NotDone;
# 47 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx”
class BRepBuilderAPI_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepBuilderAPI_Command(){Delete() ; }

virtual Standard_Boolean IsDone() const;

void Check() const;

protected:

BRepBuilderAPI_Command();

void Done() ;

void NotDone() ;

private:

Standard_Boolean myDone;

};
# 33 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 2

class StdFail_NotDone;
class TopoDS_Shape;
class TopTools_ListOfShape;
# 54 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
class BRepBuilderAPI_MakeShape : public BRepBuilderAPI_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepBuilderAPI_MakeShape(){Delete() ; }

virtual void Build() ;

const TopoDS_Shape& Shape() const;
operator TopoDS_Shape() const;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;

virtual Standard_Boolean IsDeleted(const TopoDS_Shape& S) ;

protected:

BRepBuilderAPI_MakeShape();

TopoDS_Shape myShape;
TopTools_ListOfShape myGenerated;

private:
# 126 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
};
# 48 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

class BOP_HistoryCollector;
class TopoDS_Shape;
class BOPTools_DSFiller;
class TopTools_ListOfShape;
# 71 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
class BRepAlgoAPI_BooleanOperation : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 96 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
void SetOperation(const BOP_Operation anOp) ;

virtual void Build() ;

const TopoDS_Shape& Shape1() const;

const TopoDS_Shape& Shape2() const;

BOP_Operation Operation() const;

Standard_Boolean BuilderCanWork() const;
# 125 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
Standard_Integer ErrorStatus() const;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& aS) ;

virtual Standard_Boolean IsDeleted(const TopoDS_Shape& aS) ;

virtual const TopTools_ListOfShape& Modified2(const TopoDS_Shape& aS) ;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;

virtual Standard_Boolean HasModified() const;

virtual Standard_Boolean HasGenerated() const;

virtual Standard_Boolean HasDeleted() const;

void Destroy() ;
virtual ~BRepAlgoAPI_BooleanOperation(){Destroy();}

const TopTools_ListOfShape& SectionEdges() const;

protected:

BRepAlgoAPI_BooleanOperation(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOP_Operation anOperation);

BRepAlgoAPI_BooleanOperation(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOPTools_DSFiller& aDSF,const BOP_Operation anOperation);

Standard_Boolean PrepareFiller() ;

TopoDS_Shape myS1;
TopoDS_Shape myS2;
Standard_Boolean myBuilderCanWork;
BOP_Operation myOperation;
Standard_Integer myErrorStatus;
BOPTools_PDSFiller myDSFiller;
BOP_PBuilder myBuilder;
Handle_BOP_HistoryCollector myHistory;

private:

Standard_Integer myEntryType;

};
# 27 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx” 2

class TopoDS_Shape;
class BOPTools_DSFiller;
# 45 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
class BRepAlgoAPI_Fuse : public BRepAlgoAPI_BooleanOperation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,const TopoDS_Shape& S2);

BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOPTools_DSFiller& aDSF);

protected:
# 84 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
private:
# 94 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
};
# 4 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepLib_EdgeError.hxx” 1
# 27 “/usr/include/opencascade/BRepLib_EdgeError.hxx”
enum BRepLib_EdgeError {
BRepLib_EdgeDone,
BRepLib_PointProjectionFailed,
BRepLib_ParameterOutOfRange,
BRepLib_DifferentPointsOnClosedCurve,
BRepLib_PointWithInfiniteParameter,
BRepLib_DifferentsPointAndParameter,
BRepLib_LineThroughIdenticPoints
};
# 27 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2

# 1 “/usr/include/opencascade/TopoDS_Vertex.hxx” 1
# 45 “/usr/include/opencascade/TopoDS_Vertex.hxx”
class TopoDS_Vertex : public TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Vertex();

protected:
# 81 “/usr/include/opencascade/TopoDS_Vertex.hxx”
private:
# 91 “/usr/include/opencascade/TopoDS_Vertex.hxx”
};
# 30 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2

# 1 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 1
# 32 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
# 1 “/usr/include/opencascade/BRepLib_Command.hxx” 1
# 28 “/usr/include/opencascade/BRepLib_Command.hxx”
class StdFail_NotDone;
# 47 “/usr/include/opencascade/BRepLib_Command.hxx”
class BRepLib_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepLib_Command(){Delete() ; }

Standard_Boolean IsDone() const;

void Check() const;

protected:

BRepLib_Command();

void Done() ;

void NotDone() ;

private:

Standard_Boolean myDone;

};
# 33 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 2

# 1 “/usr/include/opencascade/BRepLib_ShapeModification.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_ShapeModification.hxx”
enum BRepLib_ShapeModification {
BRepLib_Preserved,
BRepLib_Deleted,
BRepLib_Trimmed,
BRepLib_Merged,
BRepLib_BoundaryModified
};
# 36 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 2

class StdFail_NotDone;
class TopoDS_Shape;
class TopoDS_Face;
class TopTools_ListOfShape;
class TopoDS_Edge;
# 62 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
class BRepLib_MakeShape : public BRepLib_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

void Build() ;

const TopoDS_Shape& Shape() const;
operator TopoDS_Shape() const;

virtual BRepLib_ShapeModification FaceStatus(const TopoDS_Face& F) const;

virtual Standard_Boolean HasDescendants(const TopoDS_Face& F) const;

virtual const TopTools_ListOfShape& DescendantFaces(const TopoDS_Face& F) ;

virtual Standard_Integer NbSurfaces() const;

virtual const TopTools_ListOfShape& NewFaces(const Standard_Integer I) ;

virtual const TopTools_ListOfShape& FacesFromEdges(const TopoDS_Edge& E) ;

protected:

BRepLib_MakeShape();

TopoDS_Shape myShape;
TopTools_ListOfShape myGenFaces;
TopTools_ListOfShape myNewFaces;
TopTools_ListOfShape myEdgFaces;

private:
# 141 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
};
# 33 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2
# 46 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
class StdFail_NotDone;
class TopoDS_Vertex;
class gp_Pnt;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class Geom_Curve;
class Geom2d_Curve;
class Geom_Surface;
class TopoDS_Edge;
# 98 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
class BRepLib_MakeEdge : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeEdge();

BRepLib_MakeEdge(const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Lin& L);

BRepLib_MakeEdge(const gp_Lin& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Lin& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Lin& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Circ& L);

BRepLib_MakeEdge(const gp_Circ& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Circ& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Circ& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Elips& L);

BRepLib_MakeEdge(const gp_Elips& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Elips& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Elips& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Hypr& L);

BRepLib_MakeEdge(const gp_Hypr& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Hypr& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Hypr& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Parab& L);

BRepLib_MakeEdge(const gp_Parab& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Parab& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Parab& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

void Init(const Handle_Geom_Curve& C) ;

void Init(const Handle_Geom_Curve& C,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

BRepLib_EdgeError Error() const;

const TopoDS_Edge& Edge() const;
operator TopoDS_Edge() const;

const TopoDS_Vertex& Vertex1() const;

const TopoDS_Vertex& Vertex2() const;

protected:
# 287 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
private:

BRepLib_EdgeError myError;
TopoDS_Vertex myVertex1;
TopoDS_Vertex myVertex2;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 2
# 47 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_EdgeError.hxx” 1
# 49 “/usr/include/opencascade/BRepBuilderAPI_EdgeError.hxx”
enum BRepBuilderAPI_EdgeError {
BRepBuilderAPI_EdgeDone,
BRepBuilderAPI_PointProjectionFailed,
BRepBuilderAPI_ParameterOutOfRange,
BRepBuilderAPI_DifferentPointsOnClosedCurve,
BRepBuilderAPI_PointWithInfiniteParameter,
BRepBuilderAPI_DifferentsPointAndParameter,
BRepBuilderAPI_LineThroughIdenticPoints
};
# 48 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 2

class StdFail_NotDone;
class TopoDS_Vertex;
class gp_Pnt;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class Geom_Curve;
class Geom2d_Curve;
class Geom_Surface;
class TopoDS_Edge;
# 101 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
class BRepBuilderAPI_MakeEdge : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepBuilderAPI_MakeEdge();

BRepBuilderAPI_MakeEdge(const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);
# 284 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

void Init(const Handle_Geom_Curve& C) ;

void Init(const Handle_Geom_Curve& C,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_EdgeError Error() const;

const TopoDS_Edge& Edge() const;
operator TopoDS_Edge() const;

const TopoDS_Vertex& Vertex1() const;
# 352 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
const TopoDS_Vertex& Vertex2() const;

protected:
# 368 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
private:

BRepLib_MakeEdge myMakeEdge;

};
# 6 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeFace.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepLib_FaceError.hxx” 1
# 28 “/usr/include/opencascade/BRepLib_FaceError.hxx”
enum BRepLib_FaceError {
BRepLib_FaceDone,
BRepLib_NoFace,
BRepLib_NotPlanar,
BRepLib_CurveProjectionFailed,
BRepLib_ParametersOutOfRange,
BRepLib_SurfaceNotC2
};
# 27 “/usr/include/opencascade/BRepLib_MakeFace.hxx” 2
# 40 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
class StdFail_NotDone;
class TopoDS_Face;
class gp_Pln;
class gp_Cylinder;
class gp_Cone;
class gp_Sphere;
class gp_Torus;
class Geom_Surface;
class TopoDS_Wire;
# 87 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
class BRepLib_MakeFace : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeFace();

BRepLib_MakeFace(const TopoDS_Face& F);

BRepLib_MakeFace(const gp_Pln& P);

BRepLib_MakeFace(const gp_Cylinder& C);

BRepLib_MakeFace(const gp_Cone& C);

BRepLib_MakeFace(const gp_Sphere& S);

BRepLib_MakeFace(const gp_Torus& C);

BRepLib_MakeFace(const Handle_Geom_Surface& S);

BRepLib_MakeFace(const gp_Pln& P,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Cylinder& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Cone& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Sphere& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Torus& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const TopoDS_Wire& W,const Standard_Boolean OnlyPlane = (Standard_Boolean) 0);

BRepLib_MakeFace(const gp_Pln& P,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Cylinder& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Cone& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Sphere& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Torus& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const Handle_Geom_Surface& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const TopoDS_Face& F,const TopoDS_Wire& W);

void Init(const TopoDS_Face& F) ;

void Init(const Handle_Geom_Surface& S,const Standard_Boolean Bound = (Standard_Boolean) 1) ;

void Init(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax) ;

void Add(const TopoDS_Wire& W) ;

BRepLib_FaceError Error() const;

const TopoDS_Face& Face() const;
operator TopoDS_Face() const;

protected:
# 211 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
private:

void CheckInside() ;

BRepLib_FaceError myError;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 2
# 41 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_FaceError.hxx” 1
# 39 “/usr/include/opencascade/BRepBuilderAPI_FaceError.hxx”
enum BRepBuilderAPI_FaceError {
BRepBuilderAPI_FaceDone,
BRepBuilderAPI_NoFace,
BRepBuilderAPI_NotPlanar,
BRepBuilderAPI_CurveProjectionFailed,
BRepBuilderAPI_ParametersOutOfRange,
BRepBuilderAPI_SurfaceNotC2
};
# 42 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 2

class StdFail_NotDone;
class TopoDS_Face;
class gp_Pln;
class gp_Cylinder;
class gp_Cone;
class gp_Sphere;
class gp_Torus;
class Geom_Surface;
class TopoDS_Wire;
# 101 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
class BRepBuilderAPI_MakeFace : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepBuilderAPI_MakeFace();

BRepBuilderAPI_MakeFace(const TopoDS_Face& F);

BRepBuilderAPI_MakeFace(const gp_Pln& P);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C);

BRepBuilderAPI_MakeFace(const gp_Cone& C);

BRepBuilderAPI_MakeFace(const gp_Sphere& S);

BRepBuilderAPI_MakeFace(const gp_Torus& C);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S);

BRepBuilderAPI_MakeFace(const gp_Pln& P,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Cone& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Sphere& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Torus& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const TopoDS_Wire& W,const Standard_Boolean OnlyPlane = (Standard_Boolean) 0);

BRepBuilderAPI_MakeFace(const gp_Pln& P,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Cone& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Sphere& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Torus& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);
# 233 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
BRepBuilderAPI_MakeFace(const TopoDS_Face& F,const TopoDS_Wire& W);

void Init(const TopoDS_Face& F) ;
# 249 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Init(const Handle_Geom_Surface& S,const Standard_Boolean Bound = (Standard_Boolean) 1) ;
# 262 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Init(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax) ;
# 277 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Add(const TopoDS_Wire& W) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_FaceError Error() const;

const TopoDS_Face& Face() const;
operator TopoDS_Face() const;

protected:
# 310 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
private:

BRepLib_MakeFace myMakeFace;

};
# 7 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepLib_WireError.hxx” 1
# 27 “/usr/include/opencascade/BRepLib_WireError.hxx”
enum BRepLib_WireError {
BRepLib_WireDone,
BRepLib_EmptyWire,
BRepLib_DisconnectedWire,
BRepLib_NonManifoldWire
};
# 27 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

# 1 “/usr/include/opencascade/TopoDS_Edge.hxx” 1
# 45 “/usr/include/opencascade/TopoDS_Edge.hxx”
class TopoDS_Edge : public TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Edge();

protected:
# 81 “/usr/include/opencascade/TopoDS_Edge.hxx”
private:
# 91 “/usr/include/opencascade/TopoDS_Edge.hxx”
};
# 30 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

# 1 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 1
# 26 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_BasicMap.hxx” 1
# 32 “/usr/include/opencascade/TCollection_BasicMap.hxx”
# 1 “/usr/include/opencascade/TCollection_MapNodePtr.hxx” 1
# 25 “/usr/include/opencascade/TCollection_MapNodePtr.hxx”
class TCollection_MapNode;

typedef TCollection_MapNode* TCollection_MapNodePtr;
# 33 “/usr/include/opencascade/TCollection_BasicMap.hxx” 2

class TCollection_BasicMapIterator;
# 105 “/usr/include/opencascade/TCollection_BasicMap.hxx”
class TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

Standard_Integer NbBuckets() const;

Standard_Integer Extent() const;

Standard_Boolean IsEmpty() const;

void Statistics(ostream& S) const;

friend class TCollection_BasicMapIterator;

protected:
# 151 “/usr/include/opencascade/TCollection_BasicMap.hxx”
TCollection_BasicMap(const Standard_Integer NbBuckets,const Standard_Boolean single);

Standard_Boolean BeginResize(const Standard_Integer NbBuckets,Standard_Integer& NewBuckets,TCollection_MapNodePtr& data1,TCollection_MapNodePtr& data2) const;

void EndResize(const Standard_Integer NbBuckets,const Standard_Integer NewBuckets,const TCollection_MapNodePtr& data1,const TCollection_MapNodePtr& data2) ;

Standard_Boolean Resizable() const;

void Increment() ;

void Decrement() ;

void Destroy() ;

TCollection_MapNodePtr myData1;
TCollection_MapNodePtr myData2;

private:

Standard_Boolean isDouble;
Standard_Boolean mySaturated;
Standard_Integer myNbBuckets;
Standard_Integer mySize;

};

# 1 “/usr/include/opencascade/TCollection_BasicMap.lxx” 1
# 12 “/usr/include/opencascade/TCollection_BasicMap.lxx”
inline Standard_Integer TCollection_BasicMap::NbBuckets() const
{
return myNbBuckets;
}

inline Standard_Integer TCollection_BasicMap::Extent() const
{
return mySize;
}

inline Standard_Boolean TCollection_BasicMap::IsEmpty() const
{
return mySize == 0;
}

inline Standard_Boolean TCollection_BasicMap::Resizable()const
{
return IsEmpty() || (!mySaturated && (mySize > myNbBuckets));
}

inline void TCollection_BasicMap::Increment()
{
mySize++;
}

inline void TCollection_BasicMap::Decrement()
{
mySize–;
}
# 199 “/usr/include/opencascade/TCollection_BasicMap.hxx” 2
# 27 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopTools_StdMapNodeOfMapOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_StdMapNodeOfMapOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_StdMapNodeOfMapOfShape;
Handle_Standard_Type& TopTools_StdMapNodeOfMapOfShape_Type_();

class Handle_TopTools_StdMapNodeOfMapOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_StdMapNodeOfMapOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_StdMapNodeOfMapOfShape(const Handle_TopTools_StdMapNodeOfMapOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_StdMapNodeOfMapOfShape(const TopTools_StdMapNodeOfMapOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_StdMapNodeOfMapOfShape& operator=(const Handle_TopTools_StdMapNodeOfMapOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_StdMapNodeOfMapOfShape& operator=(const TopTools_StdMapNodeOfMapOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_StdMapNodeOfMapOfShape* operator->() const
{
return (TopTools_StdMapNodeOfMapOfShape *)ControlAccess();
}

static const Handle_TopTools_StdMapNodeOfMapOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 2

class Standard_DomainError;
class TopoDS_Shape;
class TopTools_ShapeMapHasher;
class TopTools_StdMapNodeOfMapOfShape;
class TopTools_MapIteratorOfMapOfShape;
# 52 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
class TopTools_MapOfShape : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_MapOfShape(const Standard_Integer NbBuckets = 1);

TopTools_MapOfShape& Assign(const TopTools_MapOfShape& Other) ;
TopTools_MapOfShape& operator =(const TopTools_MapOfShape& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_MapOfShape()
{
Clear();
}

Standard_Boolean Add(const TopoDS_Shape& aKey) ;

Standard_Boolean Contains(const TopoDS_Shape& aKey) const;

Standard_Boolean Remove(const TopoDS_Shape& aKey) ;

protected:
# 116 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
private:

TopTools_MapOfShape(const TopTools_MapOfShape& Other);

};
# 36 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

class StdFail_NotDone;
class TopoDS_Edge;
class TopoDS_Wire;
class TopTools_ListOfShape;
class TopoDS_Vertex;
# 97 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
class BRepLib_MakeWire : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeWire();

BRepLib_MakeWire(const TopoDS_Edge& E);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3,const TopoDS_Edge& E4);

BRepLib_MakeWire(const TopoDS_Wire& W);

BRepLib_MakeWire(const TopoDS_Wire& W,const TopoDS_Edge& E);

void Add(const TopoDS_Edge& E) ;

void Add(const TopoDS_Wire& W) ;

void Add(const TopTools_ListOfShape& L) ;

BRepLib_WireError Error() const;

const TopoDS_Wire& Wire() const;
operator TopoDS_Wire() const;

const TopoDS_Edge& Edge() const;

const TopoDS_Vertex& Vertex() const;

protected:
# 178 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
private:

BRepLib_WireError myError;
TopoDS_Edge myEdge;
TopoDS_Vertex myVertex;
TopTools_MapOfShape myVertices;
TopoDS_Vertex FirstVertex;
TopoDS_Vertex VF;
TopoDS_Vertex VL;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 2
# 35 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_WireError.hxx” 1
# 35 “/usr/include/opencascade/BRepBuilderAPI_WireError.hxx”
enum BRepBuilderAPI_WireError {
BRepBuilderAPI_WireDone,
BRepBuilderAPI_EmptyWire,
BRepBuilderAPI_DisconnectedWire,
BRepBuilderAPI_NonManifoldWire
};
# 36 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 2

class StdFail_NotDone;
class TopoDS_Edge;
class TopoDS_Wire;
class TopTools_ListOfShape;
class TopoDS_Vertex;
# 82 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
class BRepBuilderAPI_MakeWire : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 109 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
BRepBuilderAPI_MakeWire();

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E);

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2);

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3);
# 140 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3,const TopoDS_Edge& E4);

BRepBuilderAPI_MakeWire(const TopoDS_Wire& W);

BRepBuilderAPI_MakeWire(const TopoDS_Wire& W,const TopoDS_Edge& E);
# 161 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
void Add(const TopoDS_Edge& E) ;

void Add(const TopoDS_Wire& W) ;
# 173 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
void Add(const TopTools_ListOfShape& L) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_WireError Error() const;

const TopoDS_Wire& Wire() const;
operator TopoDS_Wire() const;
# 200 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
const TopoDS_Edge& Edge() const;

const TopoDS_Vertex& Vertex() const;

protected:
# 224 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
private:

BRepLib_MakeWire myMakeWire;

};
# 8 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
# 1 “/usr/include/opencascade/gp_Trsf.hxx” 1
# 29 “/usr/include/opencascade/gp_Trsf.hxx”
# 1 “/usr/include/opencascade/gp_TrsfForm.hxx” 1
# 26 “/usr/include/opencascade/gp_TrsfForm.hxx”
enum gp_TrsfForm {
gp_Identity,
gp_Rotation,
gp_Translation,
gp_PntMirror,
gp_Ax1Mirror,
gp_Ax2Mirror,
gp_Scale,
gp_CompoundTrsf,
gp_Other
};
# 30 “/usr/include/opencascade/gp_Trsf.hxx” 2

# 1 “/usr/include/opencascade/gp_Mat.hxx” 1
# 40 “/usr/include/opencascade/gp_Mat.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_XYZ;
class gp_Trsf;
class gp_GTrsf;
# 54 “/usr/include/opencascade/gp_Mat.hxx”
Handle_Standard_Type& gp_Mat_Type_();

class gp_Mat {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Mat();

gp_Mat(const Standard_Real a11,const Standard_Real a12,const Standard_Real a13,const Standard_Real a21,const Standard_Real a22,const Standard_Real a23,const Standard_Real a31,const Standard_Real a32,const Standard_Real a33);

gp_Mat(const gp_XYZ& Col1,const gp_XYZ& Col2,const gp_XYZ& Col3);

void SetCol(const Standard_Integer Col,const gp_XYZ& Value) ;

void SetCols(const gp_XYZ& Col1,const gp_XYZ& Col2,const gp_XYZ& Col3) ;
# 104 “/usr/include/opencascade/gp_Mat.hxx”
void SetCross(const gp_XYZ& Ref) ;

void SetDiagonal(const Standard_Real X1,const Standard_Real X2,const Standard_Real X3) ;

void SetDot(const gp_XYZ& Ref) ;

void SetIdentity() ;

void SetRotation(const gp_XYZ& Axis,const Standard_Real Ang) ;

void SetRow(const Standard_Integer Row,const gp_XYZ& Value) ;

void SetRows(const gp_XYZ& Row1,const gp_XYZ& Row2,const gp_XYZ& Row3) ;

void SetScale(const Standard_Real S) ;

void SetValue(const Standard_Integer Row,const Standard_Integer Col,const Standard_Real Value) ;

gp_XYZ Column(const Standard_Integer Col) const;

Standard_Real Determinant() const;

gp_XYZ Diagonal() const;

gp_XYZ Row(const Standard_Integer Row) const;

const Standard_Real& Value(const Standard_Integer Row,const Standard_Integer Col) const;
const Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col) const
{
return Value(Row,Col);
}

Standard_Real& ChangeValue(const Standard_Integer Row,const Standard_Integer Col) ;
Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col)
{
return ChangeValue(Row,Col);
}

Standard_Boolean IsSingular() const;

void Add(const gp_Mat& Other) ;
void operator +=(const gp_Mat& Other)
{
Add(Other);
}

gp_Mat Added(const gp_Mat& Other) const;
gp_Mat operator +(const gp_Mat& Other) const
{
return Added(Other);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Mat Divided(const Standard_Real Scalar) const;
gp_Mat operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Invert() ;
# 226 “/usr/include/opencascade/gp_Mat.hxx”
gp_Mat Inverted() const;

gp_Mat Multiplied(const gp_Mat& Other) const;
gp_Mat operator *(const gp_Mat& Other) const
{
return Multiplied(Other);
}

void Multiply(const gp_Mat& Other) ;
void operator *=(const gp_Mat& Other)
{
Multiply(Other);
}

void PreMultiply(const gp_Mat& Other) ;

gp_Mat Multiplied(const Standard_Real Scalar) const;
gp_Mat operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Power(const Standard_Integer N) ;

gp_Mat Powered(const Standard_Integer N) const;

void Subtract(const gp_Mat& Other) ;
void operator -=(const gp_Mat& Other)
{
Subtract(Other);
}

gp_Mat Subtracted(const gp_Mat& Other) const;
gp_Mat operator -(const gp_Mat& Other) const
{
return Subtracted(Other);
}

void Transpose() ;

gp_Mat Transposed() const;
Standard_Real& _CSFDB_Getgp_Matmatrix(const Standard_Integer i1,const Standard_Integer i2) { return matrix[i1][i2]; }

friend class gp_XYZ;
friend class gp_Trsf;
friend class gp_GTrsf;

friend Handle_Standard_Type& gp_Mat_Type_();

protected:
# 312 “/usr/include/opencascade/gp_Mat.hxx”
private:

Standard_Real matrix[3][3];

};

# 1 “/usr/include/opencascade/gp_Mat.lxx” 1

# 1 “/usr/include/opencascade/gp.hxx” 1
# 28 “/usr/include/opencascade/gp.hxx”
class gp_Pnt;
class gp_Dir;
class gp_Ax1;
class gp_Ax2;
class gp_Pnt2d;
class gp_Dir2d;
class gp_Ax2d;
class gp_XYZ;
class gp_Mat;
class gp_Trsf;
class gp_GTrsf;
class gp_Pnt;
class gp_Vec;
class gp_Dir;
class gp_Ax1;
class gp_Ax2;
class gp_Ax3;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class gp_Pln;
class gp_Cylinder;
class gp_Sphere;
class gp_Torus;
class gp_Cone;
class gp_XY;
class gp_Mat2d;
class gp_Trsf2d;
class gp_GTrsf2d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Dir2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Lin2d;
class gp_Circ2d;
class gp_Elips2d;
class gp_Hypr2d;
class gp_Parab2d;
# 88 “/usr/include/opencascade/gp.hxx”
class gp {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 113 “/usr/include/opencascade/gp.hxx”
static Standard_Real Resolution() ;

static const gp_Pnt& Origin() ;

static const gp_Dir& DX() ;

static const gp_Dir& DY() ;

static const gp_Dir& DZ() ;

static const gp_Ax1& OX() ;

static const gp_Ax1& OY() ;

static const gp_Ax1& OZ() ;

static const gp_Ax2& XOY() ;

static const gp_Ax2& ZOX() ;

static const gp_Ax2& YOZ() ;

static const gp_Pnt2d& Origin2d() ;

static const gp_Dir2d& DX2d() ;

static const gp_Dir2d& DY2d() ;

static const gp_Ax2d& OX2d() ;

static const gp_Ax2d& OY2d() ;

protected:
# 185 “/usr/include/opencascade/gp.hxx”
private:
# 194 “/usr/include/opencascade/gp.hxx”
friend class gp_XYZ;
friend class gp_Mat;
friend class gp_Trsf;
friend class gp_GTrsf;
friend class gp_Pnt;
friend class gp_Vec;
friend class gp_Dir;
friend class gp_Ax1;
friend class gp_Ax2;
friend class gp_Ax3;
friend class gp_Lin;
friend class gp_Circ;
friend class gp_Elips;
friend class gp_Hypr;
friend class gp_Parab;
friend class gp_Pln;
friend class gp_Cylinder;
friend class gp_Sphere;
friend class gp_Torus;
friend class gp_Cone;
friend class gp_XY;
friend class gp_Mat2d;
friend class gp_Trsf2d;
friend class gp_GTrsf2d;
friend class gp_Pnt2d;
friend class gp_Vec2d;
friend class gp_Dir2d;
friend class gp_Ax2d;
friend class gp_Ax22d;
friend class gp_Lin2d;
friend class gp_Circ2d;
friend class gp_Elips2d;
friend class gp_Hypr2d;
friend class gp_Parab2d;

};

# 1 “/usr/include/opencascade/gp.lxx” 1

inline Standard_Real gp::Resolution ()
{
return RealSmall();
}
# 233 “/usr/include/opencascade/gp.hxx” 2
# 4 “/usr/include/opencascade/gp_Mat.lxx” 2
# 1 “/usr/include/opencascade/Standard_OutOfRange.hxx” 1
# 29 “/usr/include/opencascade/Standard_OutOfRange.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_RangeError.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_RangeError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_DomainError.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_DomainError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Failure.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_Failure.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class Standard_Failure;
Handle_Standard_Type& Standard_Failure_Type_();

class Handle_Standard_Failure : public Handle_Standard_Transient {
public:
Handle_Standard_Failure():Handle_Standard_Transient() {}
Handle_Standard_Failure(const Handle_Standard_Failure& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_Standard_Failure(const Standard_Failure* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_Standard_Failure& operator=(const Handle_Standard_Failure& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Failure& operator=(const Standard_Failure* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_Failure* operator->() const
{
return (Standard_Failure *)ControlAccess();
}

static const Handle_Standard_Failure DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_DomainError.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Failure;
class Standard_DomainError;
Handle_Standard_Type& Standard_DomainError_Type_();

class Handle_Standard_DomainError : public Handle_Standard_Failure {
public:
Handle_Standard_DomainError():Handle_Standard_Failure() {}
Handle_Standard_DomainError(const Handle_Standard_DomainError& aHandle) : Handle_Standard_Failure(aHandle)
{
}

Handle_Standard_DomainError(const Standard_DomainError* anItem) : Handle_Standard_Failure((Standard_Failure *)anItem)
{
}

Handle_Standard_DomainError& operator=(const Handle_Standard_DomainError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_DomainError& operator=(const Standard_DomainError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_DomainError* operator->() const
{
return (Standard_DomainError *)ControlAccess();
}

static const Handle_Standard_DomainError DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_RangeError.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class Standard_RangeError;
Handle_Standard_Type& Standard_RangeError_Type_();

class Handle_Standard_RangeError : public Handle_Standard_DomainError {
public:
Handle_Standard_RangeError():Handle_Standard_DomainError() {}
Handle_Standard_RangeError(const Handle_Standard_RangeError& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_Standard_RangeError(const Standard_RangeError* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_Standard_RangeError& operator=(const Handle_Standard_RangeError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_RangeError& operator=(const Standard_RangeError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_RangeError* operator->() const
{
return (Standard_RangeError *)ControlAccess();
}

static const Handle_Standard_RangeError DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_RangeError;
class Standard_OutOfRange;
Handle_Standard_Type& Standard_OutOfRange_Type_();

class Handle_Standard_OutOfRange : public Handle_Standard_RangeError {
public:
Handle_Standard_OutOfRange():Handle_Standard_RangeError() {}
Handle_Standard_OutOfRange(const Handle_Standard_OutOfRange& aHandle) : Handle_Standard_RangeError(aHandle)
{
}

Handle_Standard_OutOfRange(const Standard_OutOfRange* anItem) : Handle_Standard_RangeError((Standard_RangeError *)anItem)
{
}

Handle_Standard_OutOfRange& operator=(const Handle_Standard_OutOfRange& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_OutOfRange& operator=(const Standard_OutOfRange* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_OutOfRange* operator->() const
{
return (Standard_OutOfRange *)ControlAccess();
}

static const Handle_Standard_OutOfRange DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2

# 1 “/usr/include/opencascade/Standard_SStream.hxx” 1
# 52 “/usr/include/opencascade/Standard_SStream.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_SStream_Type_();

class Standard_SStream : public strstream {

public:
Standard_SStream();
Standard_SStream(ostream& );
~Standard_SStream();
};
# 34 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2

# 1 “/usr/include/opencascade/Standard_RangeError.hxx” 1
# 38 “/usr/include/opencascade/Standard_RangeError.hxx”
# 1 “/usr/include/opencascade/Standard_DomainError.hxx” 1
# 38 “/usr/include/opencascade/Standard_DomainError.hxx”
# 1 “/usr/include/opencascade/Standard_Failure.hxx” 1
# 45 “/usr/include/opencascade/Standard_Failure.hxx”
class Standard_NoSuchObject;

class Standard_Failure : public Standard_Transient {

public:

Standard_Failure();
Standard_Failure (const Standard_Failure& f);

Standard_Failure(const Standard_CString aString);
Standard_Failure& operator= (const Standard_Failure& f);

void Destroy() ;
~Standard_Failure()
{
Destroy();
}
# 83 “/usr/include/opencascade/Standard_Failure.hxx”
void Print(ostream& s) const;
void operator<<(ostream& s) const
{
Print(s);
}

Standard_CString GetMessageString() const;

void SetMessageString(const Standard_CString aMessage) ;

void Reraise() ;

void Reraise(const Standard_CString aMessage) ;

static void Raise(const Standard_CString aMessage = “”) ;

static void Raise(Standard_SStream& aReason) ;

static Handle_Standard_Failure NewInstance(const Standard_CString aMessage) ;

void Jump() const;

static Handle_Standard_Failure Caught() ;

const Handle_Standard_Type& DynamicType() const;

protected:
# 147 “/usr/include/opencascade/Standard_Failure.hxx”
virtual void Throw() const;

private:

Standard_CString myMessage;

};

# 1 “/usr/include/opencascade/Standard_Failure.lxx” 1
# 9 “/usr/include/opencascade/Standard_Failure.lxx”
inline ostream& operator <<(ostream& AStream,
const Handle_Standard_Failure& AFailure)
{
AFailure->Print(AStream);
return AStream;
}

inline Standard_CString Standard_Failure::GetMessageString () const
{
return (myMessage ? myMessage+sizeof(Standard_Integer) : myMessage);
}
# 169 “/usr/include/opencascade/Standard_Failure.hxx” 2
# 39 “/usr/include/opencascade/Standard_DomainError.hxx” 2
# 49 “/usr/include/opencascade/Standard_DomainError.hxx”
class Standard_DomainError : public Standard_Failure {

virtual void Throw() const;

public:
Standard_DomainError():Standard_Failure(){}
Standard_DomainError(const Standard_CString AString):Standard_Failure(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_DomainError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_DomainError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 39 “/usr/include/opencascade/Standard_RangeError.hxx” 2
# 49 “/usr/include/opencascade/Standard_RangeError.hxx”
class Standard_RangeError : public Standard_DomainError {

virtual void Throw() const;

public:
Standard_RangeError():Standard_DomainError(){}
Standard_RangeError(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_RangeError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_RangeError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 39 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2
# 49 “/usr/include/opencascade/Standard_OutOfRange.hxx”
class Standard_OutOfRange : public Standard_RangeError {

virtual void Throw() const;

public:
Standard_OutOfRange():Standard_RangeError(){}
Standard_OutOfRange(const Standard_CString AString):Standard_RangeError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_OutOfRange NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_OutOfRange_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 5 “/usr/include/opencascade/gp_Mat.lxx” 2
# 1 “/usr/include/opencascade/Standard_ConstructionError.hxx” 1
# 29 “/usr/include/opencascade/Standard_ConstructionError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_ConstructionError.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_ConstructionError.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class Standard_ConstructionError;
Handle_Standard_Type& Standard_ConstructionError_Type_();

class Handle_Standard_ConstructionError : public Handle_Standard_DomainError {
public:
Handle_Standard_ConstructionError():Handle_Standard_DomainError() {}
Handle_Standard_ConstructionError(const Handle_Standard_ConstructionError& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_Standard_ConstructionError(const Standard_ConstructionError* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_Standard_ConstructionError& operator=(const Handle_Standard_ConstructionError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_ConstructionError& operator=(const Standard_ConstructionError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_ConstructionError* operator->() const
{
return (Standard_ConstructionError *)ControlAccess();
}

static const Handle_Standard_ConstructionError DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/Standard_ConstructionError.hxx” 2
# 49 “/usr/include/opencascade/Standard_ConstructionError.hxx”
class Standard_ConstructionError : public Standard_DomainError {

virtual void Throw() const;

public:
Standard_ConstructionError():Standard_DomainError(){}
Standard_ConstructionError(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_ConstructionError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_ConstructionError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 6 “/usr/include/opencascade/gp_Mat.lxx” 2
# 37 “/usr/include/opencascade/gp_Mat.lxx”
inline gp_Mat::gp_Mat () {
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] =
((Standard_Real*)M)[1] =
((Standard_Real*)M)[2] =
((Standard_Real*)M)[3] =
((Standard_Real*)M)[4] =
((Standard_Real*)M)[5] =
((Standard_Real*)M)[6] =
((Standard_Real*)M)[7] =
((Standard_Real*)M)[8] = 0.0;
}

inline gp_Mat::gp_Mat (const Standard_Real a11,
const Standard_Real a12,
const Standard_Real a13,
const Standard_Real a21,
const Standard_Real a22,
const Standard_Real a23,
const Standard_Real a31,
const Standard_Real a32,
const Standard_Real a33) {

const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = a11;
((Standard_Real*)M)[1] = a12;
((Standard_Real*)M)[2] = a13;
((Standard_Real*)M)[3] = a21;
((Standard_Real*)M)[4] = a22;
((Standard_Real*)M)[5] = a23;
((Standard_Real*)M)[6] = a31;
((Standard_Real*)M)[7] = a32;
((Standard_Real*)M)[8] = a33;
}

inline void gp_Mat::SetDiagonal (const Standard_Real X1,
const Standard_Real X2,
const Standard_Real X3)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = X1; ((Standard_Real*)M)[4] = X2; ((Standard_Real*)M)[8] = X3;
}

inline void gp_Mat::SetIdentity ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[4] = ((Standard_Real*)M)[8] = 1.0;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = ((Standard_Real*)M)[5] = ((Standard_Real*)M)[6] = ((Standard_Real*)M)[7] = 0.0;
}

inline void gp_Mat::SetScale (const Standard_Real S)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[4] = ((Standard_Real*)M)[8] = S;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = ((Standard_Real*)M)[5] = ((Standard_Real*)M)[6] = ((Standard_Real*)M)[7] = 0.0;
}

inline void gp_Mat::SetValue (const Standard_Integer Row,
const Standard_Integer Col,
const Standard_Real Value)
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

matrix[Row-1][Col-1] = Value;
}

inline Standard_Real gp_Mat::Determinant () const
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
return
((Standard_Real*)M)[0] * (((Standard_Real*)M)[4] * ((Standard_Real*)M)[8] – ((Standard_Real*)M)[7] * ((Standard_Real*)M)[5]) –
((Standard_Real*)M)[1] * (((Standard_Real*)M)[3] * ((Standard_Real*)M)[8] – ((Standard_Real*)M)[6] * ((Standard_Real*)M)[5]) +
((Standard_Real*)M)[2] * (((Standard_Real*)M)[3] * ((Standard_Real*)M)[7] – ((Standard_Real*)M)[6] * ((Standard_Real*)M)[4]);
}

inline const Standard_Real& gp_Mat::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Real& gp_Mat::ChangeValue (const Standard_Integer Row,
const Standard_Integer Col)
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Boolean gp_Mat::IsSingular () const
{

Standard_Real val = Determinant();
if (val < 0) val = – val;
return val <= gp::Resolution();
}

inline void gp_Mat::Add (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
((Standard_Real*)M)[4] = ((Standard_Real*)M)[4] + ((Standard_Real*)O)[4];
((Standard_Real*)M)[5] = ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5];
((Standard_Real*)M)[6] = ((Standard_Real*)M)[6] + ((Standard_Real*)O)[6];
((Standard_Real*)M)[7] = ((Standard_Real*)M)[7] + ((Standard_Real*)O)[7];
((Standard_Real*)M)[8] = ((Standard_Real*)M)[8] + ((Standard_Real*)O)[8];
}

inline gp_Mat gp_Mat::Added (const gp_Mat& Other) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] + ((Standard_Real*)O)[4];
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5];
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] + ((Standard_Real*)O)[6];
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] + ((Standard_Real*)O)[7];
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] + ((Standard_Real*)O)[8];
return NewMat;
}

inline void gp_Mat::Divide (const Standard_Real Scalar)
{
Standard_Real val = Scalar;
if (val < 0) val = – val;
if (val <= gp::Resolution()) Standard_ConstructionError::Raise(“gp_Mat : Divide by 0”);;

Standard_Real UnSurScalar = 1.0 / Scalar;
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= UnSurScalar;
((Standard_Real*)M)[1] *= UnSurScalar;
((Standard_Real*)M)[2] *= UnSurScalar;
((Standard_Real*)M)[3] *= UnSurScalar;
((Standard_Real*)M)[4] *= UnSurScalar;
((Standard_Real*)M)[5] *= UnSurScalar;
((Standard_Real*)M)[6] *= UnSurScalar;
((Standard_Real*)M)[7] *= UnSurScalar;
((Standard_Real*)M)[8] *= UnSurScalar;
}

inline gp_Mat gp_Mat::Divided (const Standard_Real Scalar) const
{
Standard_Real val = Scalar;
if (val < 0) val = – val;
if (val <= gp::Resolution()) Standard_ConstructionError::Raise(“gp_Mat : Divide by 0”);;

gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
Standard_Real UnSurScalar = 1.0 / Scalar;
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] * UnSurScalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] * UnSurScalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] * UnSurScalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] * UnSurScalar;
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] * UnSurScalar;
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] * UnSurScalar;
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] * UnSurScalar;
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] * UnSurScalar;
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] * UnSurScalar;
return NewMat;
}

inline gp_Mat gp_Mat::Multiplied (const gp_Mat& Other) const
{
gp_Mat NewMat = *this;
NewMat.Multiply(Other);
return NewMat;
}

inline void gp_Mat::Multiply (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
Standard_Real T00,T01,T02,T10,T11,T12,T20,T21,T22;
T00 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[6];
T01 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[7];
T02 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[8];
T10 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[6];
T11 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[7];
T12 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[8];
T20 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[6];
T21 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[7];
T22 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[8];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
((Standard_Real*)M)[2] = T02;
((Standard_Real*)M)[3] = T10;
((Standard_Real*)M)[4] = T11;
((Standard_Real*)M)[5] = T12;
((Standard_Real*)M)[6] = T20;
((Standard_Real*)M)[7] = T21;
((Standard_Real*)M)[8] = T22;
}

inline void gp_Mat::PreMultiply (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
Standard_Real T00,T01,T02,T10,T11,T12,T20,T21,T22;
T00 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[6];
T01 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[7];
T02 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[8];
T10 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[6];
T11 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[7];
T12 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[8];
T20 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[6];
T21 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[7];
T22 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[8];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
((Standard_Real*)M)[2] = T02;
((Standard_Real*)M)[3] = T10;
((Standard_Real*)M)[4] = T11;
((Standard_Real*)M)[5] = T12;
((Standard_Real*)M)[6] = T20;
((Standard_Real*)M)[7] = T21;
((Standard_Real*)M)[8] = T22;
}

inline gp_Mat gp_Mat::Multiplied (const Standard_Real Scalar) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
((Standard_Real*)N)[0] = Scalar * ((Standard_Real*)M)[0];
((Standard_Real*)N)[1] = Scalar * ((Standard_Real*)M)[1];
((Standard_Real*)N)[2] = Scalar * ((Standard_Real*)M)[2];
((Standard_Real*)N)[3] = Scalar * ((Standard_Real*)M)[3];
((Standard_Real*)N)[4] = Scalar * ((Standard_Real*)M)[4];
((Standard_Real*)N)[5] = Scalar * ((Standard_Real*)M)[5];
((Standard_Real*)N)[6] = Scalar * ((Standard_Real*)M)[6];
((Standard_Real*)N)[7] = Scalar * ((Standard_Real*)M)[7];
((Standard_Real*)N)[8] = Scalar * ((Standard_Real*)M)[8];
return NewMat;
}

inline void gp_Mat::Multiply (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= Scalar;
((Standard_Real*)M)[1] *= Scalar;
((Standard_Real*)M)[2] *= Scalar;
((Standard_Real*)M)[3] *= Scalar;
((Standard_Real*)M)[4] *= Scalar;
((Standard_Real*)M)[5] *= Scalar;
((Standard_Real*)M)[6] *= Scalar;
((Standard_Real*)M)[7] *= Scalar;
((Standard_Real*)M)[8] *= Scalar;
}

inline gp_Mat gp_Mat::Powered (const Standard_Integer N) const
{
gp_Mat MatN = *this;
MatN.Power (N);
return MatN;
}

inline void gp_Mat::Subtract (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] -= ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] -= ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] -= ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] -= ((Standard_Real*)O)[3];
((Standard_Real*)M)[4] -= ((Standard_Real*)O)[4];
((Standard_Real*)M)[5] -= ((Standard_Real*)O)[5];
((Standard_Real*)M)[6] -= ((Standard_Real*)O)[6];
((Standard_Real*)M)[7] -= ((Standard_Real*)O)[7];
((Standard_Real*)M)[8] -= ((Standard_Real*)O)[8];
}

inline gp_Mat gp_Mat::Subtracted (const gp_Mat& Other) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] – ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] – ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] – ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] – ((Standard_Real*)O)[3];
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] – ((Standard_Real*)O)[4];
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] – ((Standard_Real*)O)[5];
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] – ((Standard_Real*)O)[6];
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] – ((Standard_Real*)O)[7];
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] – ((Standard_Real*)O)[8];
return NewMat;
}

inline void gp_Mat::Transpose ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real Temp;
Temp = ((Standard_Real*)M)[1];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[3];
((Standard_Real*)M)[3] = Temp;
Temp = ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = ((Standard_Real*)M)[6];
((Standard_Real*)M)[6] = Temp;
Temp = ((Standard_Real*)M)[5];
((Standard_Real*)M)[5] = ((Standard_Real*)M)[7];
((Standard_Real*)M)[7] = Temp;
}

inline gp_Mat gp_Mat::Transposed () const
{
gp_Mat NewMat = *this;
NewMat.Transpose();
return NewMat;
}

inline gp_Mat operator* (const Standard_Real Scalar, const gp_Mat& Mat3D)
{ return Mat3D.Multiplied (Scalar); }
# 327 “/usr/include/opencascade/gp_Mat.hxx” 2
# 33 “/usr/include/opencascade/gp_Trsf.hxx” 2

# 1 “/usr/include/opencascade/gp_XYZ.hxx” 1
# 40 “/usr/include/opencascade/gp_XYZ.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Mat;
# 52 “/usr/include/opencascade/gp_XYZ.hxx”
Handle_Standard_Type& gp_XYZ_Type_();
# 61 “/usr/include/opencascade/gp_XYZ.hxx”
class gp_XYZ {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_XYZ();

gp_XYZ(const Standard_Real X,const Standard_Real Y,const Standard_Real Z);

void SetCoord(const Standard_Real X,const Standard_Real Y,const Standard_Real Z) ;

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& X,Standard_Real& Y,Standard_Real& Z) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

Standard_Real Modulus() const;

Standard_Real SquareModulus() const;
# 127 “/usr/include/opencascade/gp_XYZ.hxx”
Standard_Boolean IsEqual(const gp_XYZ& Other,const Standard_Real Tolerance) const;

void Add(const gp_XYZ& Other) ;
void operator +=(const gp_XYZ& Other)
{
Add(Other);
}

gp_XYZ Added(const gp_XYZ& Other) const;
gp_XYZ operator +(const gp_XYZ& Other) const
{
return Added(Other);
}

void Cross(const gp_XYZ& Right) ;
void operator ^=(const gp_XYZ& Right)
{
Cross(Right);
}

gp_XYZ Crossed(const gp_XYZ& Right) const;
gp_XYZ operator ^(const gp_XYZ& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_XYZ& Right) const;

Standard_Real CrossSquareMagnitude(const gp_XYZ& Right) const;

void CrossCross(const gp_XYZ& Coord1,const gp_XYZ& Coord2) ;

gp_XYZ CrossCrossed(const gp_XYZ& Coord1,const gp_XYZ& Coord2) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_XYZ Divided(const Standard_Real Scalar) const;
gp_XYZ operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_XYZ& Other) const;
Standard_Real operator *(const gp_XYZ& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_XYZ& Coord1,const gp_XYZ& Coord2) const;

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Multiply(const gp_XYZ& Other) ;
void operator *=(const gp_XYZ& Other)
{
Multiply(Other);
}

void Multiply(const gp_Mat& Matrix) ;
void operator *=(const gp_Mat& Matrix)
{
Multiply(Matrix);
}

gp_XYZ Multiplied(const Standard_Real Scalar) const;
gp_XYZ operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

gp_XYZ Multiplied(const gp_XYZ& Other) const;

gp_XYZ Multiplied(const gp_Mat& Matrix) const;
gp_XYZ operator *(const gp_Mat& Matrix) const
{
return Multiplied(Matrix);
}

void Normalize() ;

gp_XYZ Normalized() const;

void Reverse() ;

gp_XYZ Reversed() const;

void Subtract(const gp_XYZ& Right) ;
void operator -=(const gp_XYZ& Right)
{
Subtract(Right);
}

gp_XYZ Subtracted(const gp_XYZ& Right) const;
gp_XYZ operator -(const gp_XYZ& Right) const
{
return Subtracted(Right);
}

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const Standard_Real A3,const gp_XYZ& XYZ3,const gp_XYZ& XYZ4) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const Standard_Real A3,const gp_XYZ& XYZ3) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const gp_XYZ& XYZ3) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const gp_XYZ& XYZ2) ;

void SetLinearForm(const gp_XYZ& XYZ1,const gp_XYZ& XYZ2) ;
Standard_Real _CSFDB_Getgp_XYZx() const { return x; }
void _CSFDB_Setgp_XYZx(const Standard_Real p) { x = p; }
Standard_Real _CSFDB_Getgp_XYZy() const { return y; }
void _CSFDB_Setgp_XYZy(const Standard_Real p) { y = p; }
Standard_Real _CSFDB_Getgp_XYZz() const { return z; }
void _CSFDB_Setgp_XYZz(const Standard_Real p) { z = p; }

friend Handle_Standard_Type& gp_XYZ_Type_();

protected:
# 342 “/usr/include/opencascade/gp_XYZ.hxx”
private:

Standard_Real x;
Standard_Real y;
Standard_Real z;

};

# 1 “/usr/include/opencascade/gp_XYZ.lxx” 1
# 19 “/usr/include/opencascade/gp_XYZ.lxx”
inline gp_XYZ::gp_XYZ () { }

inline gp_XYZ::gp_XYZ (const Standard_Real X,
const Standard_Real Y,
const Standard_Real Z) : x(X),y(Y),z(Z) { }

inline void gp_XYZ::SetCoord (const Standard_Real X,
const Standard_Real Y,
const Standard_Real Z)
{ x = X; y = Y; z = Z; }

inline void gp_XYZ::SetCoord (const Standard_Integer i,
const Standard_Real X) {
if (i < 1 || i > 3) Standard_OutOfRange::Raise(__null);;
(&x)[i-1] = X;
}

inline void gp_XYZ::SetX (const Standard_Real X)
{ x = X; }

inline void gp_XYZ::SetY (const Standard_Real Y)
{ y = Y; }

inline void gp_XYZ::SetZ (const Standard_Real Z)
{ z = Z; }

inline Standard_Real gp_XYZ::Coord (const Standard_Integer i) const {
if (i < 1 || i > 3) Standard_OutOfRange::Raise(__null);;
return (&x)[i-1];
}

inline void gp_XYZ::Coord (Standard_Real& X,
Standard_Real& Y,
Standard_Real& Z) const
{ X = x; Y = y; Z = z; }

inline Standard_Real gp_XYZ::X () const
{ return x; }

inline Standard_Real gp_XYZ::Y () const
{ return y; }

inline Standard_Real gp_XYZ::Z () const
{ return z; }

inline Standard_Real gp_XYZ::Modulus () const {
return sqrt (x * x + y * y + z * z);
}

inline Standard_Real gp_XYZ::SquareModulus () const {
return (x * x + y * y + z * z);
}

inline void gp_XYZ::Add (const gp_XYZ& Other)
{
x += Other.x;
y += Other.y;
z += Other.z;
}

inline gp_XYZ gp_XYZ::Added (const gp_XYZ& Other) const {
return gp_XYZ(x + Other.x,y + Other.y,z + Other.z);
}

inline void gp_XYZ::Cross (const gp_XYZ& Right)
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
z = x * Right.y – y * Right.x;
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::Crossed (const gp_XYZ& Right) const
{
return gp_XYZ (y * Right.z – z * Right.y,
z * Right.x – x * Right.z,
x * Right.y – y * Right.x);
}

inline Standard_Real gp_XYZ::CrossMagnitude (const gp_XYZ& Right) const
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
Standard_Real Zresult = x * Right.y – y * Right.x;
return sqrt(Xresult * Xresult + Yresult * Yresult + Zresult * Zresult);
}

inline Standard_Real gp_XYZ::CrossSquareMagnitude (const gp_XYZ& Right) const
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
Standard_Real Zresult = x * Right.y – y * Right.x;
return Xresult * Xresult + Yresult * Yresult + Zresult * Zresult;
}

inline void gp_XYZ::CrossCross (const gp_XYZ& Coord1,
const gp_XYZ& Coord2)
{
Standard_Real Xresult =
y * (Coord1.x * Coord2.y – Coord1.y * Coord2.x) –
z * (Coord1.z * Coord2.x – Coord1.x * Coord2.z);
Standard_Real Yresult =
z * (Coord1.y * Coord2.z – Coord1.z * Coord2.y) –
x * (Coord1.x * Coord2.y – Coord1.y * Coord2.x);
z =
x * (Coord1.z * Coord2.x – Coord1.x * Coord2.z) –
y * (Coord1.y * Coord2.z – Coord1.z * Coord2.y);
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::CrossCrossed (const gp_XYZ& Coord1,
const gp_XYZ& Coord2) const
{
gp_XYZ Coord0 = *this;
Coord0.CrossCross (Coord1, Coord2);
return Coord0;
}

inline void gp_XYZ::Divide (const Standard_Real Scalar)
{
x /= Scalar;
y /= Scalar;
z /= Scalar;
}

inline gp_XYZ gp_XYZ::Divided (const Standard_Real Scalar) const {
return gp_XYZ(x / Scalar,y / Scalar,z / Scalar);
}

inline Standard_Real gp_XYZ::Dot (const gp_XYZ& Other) const {
return(x * Other.x + y * Other.y + z * Other.z);
}

inline Standard_Real gp_XYZ::DotCross (const gp_XYZ& Coord1,
const gp_XYZ& Coord2) const
{
Standard_Real Xresult = Coord1.y * Coord2.z – Coord1.z * Coord2.y;
Standard_Real Yresult = Coord1.z * Coord2.x – Coord1.x * Coord2.z;
Standard_Real Zresult = Coord1.x * Coord2.y – Coord1.y * Coord2.x;
return ( x * Xresult + y * Yresult + z * Zresult);
}

inline void gp_XYZ::Multiply (const Standard_Real Scalar)
{
x *= Scalar;
y *= Scalar;
z *= Scalar;
}

inline void gp_XYZ::Multiply (const gp_XYZ& Other)
{
x *= Other.x;
y *= Other.y;
z *= Other.z;
}

inline void gp_XYZ::Multiply (const gp_Mat& Matrix)
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
Standard_Real Xresult = ((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y + ((Standard_Real*)M)[2] * z;
Standard_Real Yresult = ((Standard_Real*)M)[3] * x + ((Standard_Real*)M)[4] * y + ((Standard_Real*)M)[5] * z;
z = ((Standard_Real*)M)[6] * x + ((Standard_Real*)M)[7] * y + ((Standard_Real*)M)[8] * z;
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::Multiplied (const Standard_Real Scalar) const {
return gp_XYZ(x * Scalar,y * Scalar,z * Scalar);
}

inline gp_XYZ gp_XYZ::Multiplied (const gp_XYZ& Other) const {
return gp_XYZ(x * Other.x, y * Other.y, z * Other.z);
}

inline gp_XYZ gp_XYZ::Multiplied (const gp_Mat& Matrix) const
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
return gp_XYZ (((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y + ((Standard_Real*)M)[2] * z,
((Standard_Real*)M)[3] * x + ((Standard_Real*)M)[4] * y + ((Standard_Real*)M)[5] * z,
((Standard_Real*)M)[6] * x + ((Standard_Real*)M)[7] * y + ((Standard_Real*)M)[8] * z);
}

inline void gp_XYZ::Normalize ()
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
x = x / D; y = y / D; z = z / D;
}

inline gp_XYZ gp_XYZ::Normalized () const
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
return gp_XYZ (x / D, y / D, z / D);
}

inline void gp_XYZ::Reverse ()
{
x = – x;
y = – y;
z = – z;
}

inline gp_XYZ gp_XYZ::Reversed () const
{
return gp_XYZ(-x, -y, -z);
}

inline void gp_XYZ::Subtract (const gp_XYZ& Right)
{
x-=Right.x;
y-=Right.y;
z-=Right.z;
}

inline gp_XYZ gp_XYZ::Subtracted (const gp_XYZ& Right) const
{
return gp_XYZ(x – Right.x, y – Right.y, z – Right.z);
}

inline void gp_XYZ::SetLinearForm (const Standard_Real L,
const gp_XYZ& Left,
const Standard_Real R,
const gp_XYZ& Right) {

x = L * Left.x + R * Right.x;
y = L * Left.y + R * Right.y;
z = L * Left.z + R * Right.z;
}

inline void gp_XYZ::SetLinearForm(const Standard_Real L,
const gp_XYZ& Left,
const gp_XYZ& Right) {
x = L * Left.x + Right.x;
y = L * Left.y + Right.y;
z = L * Left.z + Right.z;
}

inline void gp_XYZ::SetLinearForm (const gp_XYZ& Left, const gp_XYZ& Right) {
x = Left.x + Right.x;
y = Left.y + Right.y;
z = Left.z + Right.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const Standard_Real A3, const gp_XYZ& XYZ3) {

x = A1 * XYZ1.x + A2 * XYZ2.x + A3 * XYZ3.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + A3 * XYZ3.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + A3 * XYZ3.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const gp_XYZ& XYZ3) {
x = A1 * XYZ1.x + A2 * XYZ2.x + XYZ3.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + XYZ3.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + XYZ3.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const Standard_Real A3, const gp_XYZ& XYZ3,
const gp_XYZ& XYZ4) {
x = A1 * XYZ1.x + A2 * XYZ2.x + A3 * XYZ3.x + XYZ4.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + A3 * XYZ3.y + XYZ4.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + A3 * XYZ3.z + XYZ4.z;

}

inline gp_XYZ operator* (const gp_Mat& Matrix, const gp_XYZ& Coord1) {
return Coord1.Multiplied (Matrix);
}

inline gp_XYZ operator* (const Standard_Real Scalar, const gp_XYZ& Coord1) {
return Coord1.Multiplied (Scalar);
}
# 359 “/usr/include/opencascade/gp_XYZ.hxx” 2
# 36 “/usr/include/opencascade/gp_Trsf.hxx” 2
# 49 “/usr/include/opencascade/gp_Trsf.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_GTrsf;
class gp_Trsf2d;
class gp_Pnt;
class gp_Ax1;
class gp_Ax2;
class gp_Ax3;
class gp_Vec;
class gp_XYZ;
class gp_Mat;
# 69 “/usr/include/opencascade/gp_Trsf.hxx”
Handle_Standard_Type& gp_Trsf_Type_();
# 85 “/usr/include/opencascade/gp_Trsf.hxx”
class gp_Trsf {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Trsf();
# 121 “/usr/include/opencascade/gp_Trsf.hxx”
gp_Trsf(const gp_Trsf2d& T);

void SetMirror(const gp_Pnt& P) ;

void SetMirror(const gp_Ax1& A1) ;

void SetMirror(const gp_Ax2& A2) ;

void SetRotation(const gp_Ax1& A1,const Standard_Real Ang) ;

void SetScale(const gp_Pnt& P,const Standard_Real S) ;
# 172 “/usr/include/opencascade/gp_Trsf.hxx”
void SetDisplacement(const gp_Ax3& FromSystem1,const gp_Ax3& ToSystem2) ;
# 192 “/usr/include/opencascade/gp_Trsf.hxx”
void SetTransformation(const gp_Ax3& FromSystem1,const gp_Ax3& ToSystem2) ;
# 204 “/usr/include/opencascade/gp_Trsf.hxx”
void SetTransformation(const gp_Ax3& ToSystem) ;

void SetTranslation(const gp_Vec& V) ;

void SetTranslation(const gp_Pnt& P1,const gp_Pnt& P2) ;

void SetTranslationPart(const gp_Vec& V) ;

void SetScaleFactor(const Standard_Real S) ;
# 236 “/usr/include/opencascade/gp_Trsf.hxx”
void SetValues(const Standard_Real a11,const Standard_Real a12,const Standard_Real a13,const Standard_Real a14,const Standard_Real a21,const Standard_Real a22,const Standard_Real a23,const Standard_Real a24,const Standard_Real a31,const Standard_Real a32,const Standard_Real a33,const Standard_Real a34,const Standard_Real Tolang,const Standard_Real TolDist) ;

Standard_Boolean IsNegative() const;

gp_TrsfForm Form() const;

Standard_Real ScaleFactor() const;

const gp_XYZ& TranslationPart() const;

gp_Mat VectorialPart() const;

const gp_Mat& HVectorialPart() const;

Standard_Real Value(const Standard_Integer Row,const Standard_Integer Col) const;

void Invert() ;
# 287 “/usr/include/opencascade/gp_Trsf.hxx”
gp_Trsf Inverted() const;

gp_Trsf Multiplied(const gp_Trsf& T) const;
gp_Trsf operator *(const gp_Trsf& T) const
{
return Multiplied(T);
}
# 310 “/usr/include/opencascade/gp_Trsf.hxx”
void Multiply(const gp_Trsf& T) ;
void operator *=(const gp_Trsf& T)
{
Multiply(T);
}

void PreMultiply(const gp_Trsf& T) ;

void Power(const Standard_Integer N) ;

gp_Trsf Powered(const Standard_Integer N) ;

void Transforms(Standard_Real& X,Standard_Real& Y,Standard_Real& Z) const;

void Transforms(gp_XYZ& Coord) const;
Standard_Real _CSFDB_Getgp_Trsfscale() const { return scale; }
void _CSFDB_Setgp_Trsfscale(const Standard_Real p) { scale = p; }
gp_TrsfForm _CSFDB_Getgp_Trsfshape() const { return shape; }
void _CSFDB_Setgp_Trsfshape(const gp_TrsfForm p) { shape = p; }
const gp_Mat& _CSFDB_Getgp_Trsfmatrix() const { return matrix; }
const gp_XYZ& _CSFDB_Getgp_Trsfloc() const { return loc; }

friend class gp_GTrsf;

friend Handle_Standard_Type& gp_Trsf_Type_();

protected:
# 359 “/usr/include/opencascade/gp_Trsf.hxx”
private:

Standard_Real scale;
gp_TrsfForm shape;
gp_Mat matrix;
gp_XYZ loc;

};

# 1 “/usr/include/opencascade/gp_Trsf.lxx” 1

# 1 “/usr/include/opencascade/gp_Trsf2d.hxx” 1
# 32 “/usr/include/opencascade/gp_Trsf2d.hxx”
# 1 “/usr/include/opencascade/gp_Mat2d.hxx” 1
# 40 “/usr/include/opencascade/gp_Mat2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Trsf2d;
class gp_GTrsf2d;
class gp_XY;
# 54 “/usr/include/opencascade/gp_Mat2d.hxx”
Handle_Standard_Type& gp_Mat2d_Type_();

class gp_Mat2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Mat2d();

gp_Mat2d(const gp_XY& Col1,const gp_XY& Col2);

void SetCol(const Standard_Integer Col,const gp_XY& Value) ;

void SetCols(const gp_XY& Col1,const gp_XY& Col2) ;

void SetDiagonal(const Standard_Real X1,const Standard_Real X2) ;

void SetIdentity() ;

void SetRotation(const Standard_Real Ang) ;

void SetRow(const Standard_Integer Row,const gp_XY& Value) ;

void SetRows(const gp_XY& Row1,const gp_XY& Row2) ;

void SetScale(const Standard_Real S) ;

void SetValue(const Standard_Integer Row,const Standard_Integer Col,const Standard_Real Value) ;

gp_XY Column(const Standard_Integer Col) const;

Standard_Real Determinant() const;

gp_XY Diagonal() const;

gp_XY Row(const Standard_Integer Row) const;

const Standard_Real& Value(const Standard_Integer Row,const Standard_Integer Col) const;
const Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col) const
{
return Value(Row,Col);
}

Standard_Real& ChangeValue(const Standard_Integer Row,const Standard_Integer Col) ;
Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col)
{
return ChangeValue(Row,Col);
}

Standard_Boolean IsSingular() const;

void Add(const gp_Mat2d& Other) ;
void operator +=(const gp_Mat2d& Other)
{
Add(Other);
}
# 169 “/usr/include/opencascade/gp_Mat2d.hxx”
gp_Mat2d Added(const gp_Mat2d& Other) const;
gp_Mat2d operator +(const gp_Mat2d& Other) const
{
return Added(Other);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Mat2d Divided(const Standard_Real Scalar) const;
gp_Mat2d operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Invert() ;

gp_Mat2d Inverted() const;

gp_Mat2d Multiplied(const gp_Mat2d& Other) const;
gp_Mat2d operator *(const gp_Mat2d& Other) const
{
return Multiplied(Other);
}

void Multiply(const gp_Mat2d& Other) ;

void PreMultiply(const gp_Mat2d& Other) ;

gp_Mat2d Multiplied(const Standard_Real Scalar) const;
gp_Mat2d operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Power(const Standard_Integer N) ;

gp_Mat2d Powered(const Standard_Integer N) const;

void Subtract(const gp_Mat2d& Other) ;
void operator -=(const gp_Mat2d& Other)
{
Subtract(Other);
}

gp_Mat2d Subtracted(const gp_Mat2d& Other) const;
gp_Mat2d operator -(const gp_Mat2d& Other) const
{
return Subtracted(Other);
}

void Transpose() ;

gp_Mat2d Transposed() const;
Standard_Real& _CSFDB_Getgp_Mat2dmatrix(const Standard_Integer i1,const Standard_Integer i2) { return matrix[i1][i2]; }

friend class gp_Trsf2d;
friend class gp_GTrsf2d;
friend class gp_XY;

friend Handle_Standard_Type& gp_Mat2d_Type_();

protected:
# 278 “/usr/include/opencascade/gp_Mat2d.hxx”
private:

Standard_Real matrix[2][2];

};

# 1 “/usr/include/opencascade/gp_Mat2d.lxx” 1
# 21 “/usr/include/opencascade/gp_Mat2d.lxx”
inline gp_Mat2d::gp_Mat2d ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = 0.0;
}

inline void gp_Mat2d::SetDiagonal (const Standard_Real X1,
const Standard_Real X2)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = X1; ((Standard_Real*)M)[3] = X2;
}

inline void gp_Mat2d::SetIdentity ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = 1.0;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = 0.0;
}

inline void gp_Mat2d::SetRotation (const Standard_Real Ang)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real SinA = sin(Ang);
Standard_Real CosA = cos(Ang);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = CosA;
((Standard_Real*)M)[1] = -SinA;
((Standard_Real*)M)[2] = SinA;
}

inline void gp_Mat2d::SetScale (const Standard_Real S)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = S;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = 0.0;
}

inline void gp_Mat2d::SetValue (const Standard_Integer Row,
const Standard_Integer Col,
const Standard_Real Value)
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

matrix[Row-1][Col-1] = Value;
}

inline Standard_Real gp_Mat2d::Determinant () const
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
return ((Standard_Real*)M)[0] * ((Standard_Real*)M)[3] – ((Standard_Real*)M)[2] * ((Standard_Real*)M)[1];
}

inline const Standard_Real& gp_Mat2d::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Real&
gp_Mat2d::ChangeValue (const Standard_Integer Row,
const Standard_Integer Col)
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Boolean gp_Mat2d::IsSingular () const
{
Standard_Real det = Determinant();
if (det < 0) det = – det;
return det <= gp::Resolution();
}

inline void gp_Mat2d::Add (const gp_Mat2d& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] += ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] += ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] += ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] += ((Standard_Real*)O)[3];
}

inline gp_Mat2d gp_Mat2d::Added (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
return NewMat2d;
}

inline void gp_Mat2d::Divide (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] /= Scalar;
((Standard_Real*)M)[1] /= Scalar;
((Standard_Real*)M)[2] /= Scalar;
((Standard_Real*)M)[3] /= Scalar;
}

inline gp_Mat2d gp_Mat2d::Divided (const Standard_Real Scalar) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] / Scalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] / Scalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] / Scalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] / Scalar;
return NewMat2d;
}

inline gp_Mat2d gp_Mat2d::Inverted () const
{
gp_Mat2d NewMat = *this;
NewMat.Invert();
return NewMat;
}

inline gp_Mat2d gp_Mat2d::Multiplied (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d = *this;
NewMat2d.Multiply(Other);
return NewMat2d;
}

inline void gp_Mat2d::Multiply (const gp_Mat2d& Other)
{
Standard_Real T00,T10;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
T00 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[2];
T10 = ((Standard_Real*)M)[2] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[3] * ((Standard_Real*)O)[2];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[3];
((Standard_Real*)M)[3] = ((Standard_Real*)M)[2] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[3] * ((Standard_Real*)O)[3];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[2] = T10;
}

inline void gp_Mat2d::PreMultiply (const gp_Mat2d& Other)
{
Standard_Real T00,T01;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
T00 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = ((Standard_Real*)O)[2] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[3] * ((Standard_Real*)M)[2];
T01 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[3];
((Standard_Real*)M)[3] = ((Standard_Real*)O)[2] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[3] * ((Standard_Real*)M)[3];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
}

inline gp_Mat2d gp_Mat2d::Multiplied (const Standard_Real Scalar) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] * Scalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] * Scalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] * Scalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] * Scalar;
return NewMat2d;
}

inline void gp_Mat2d::Multiply (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= Scalar;
((Standard_Real*)M)[1] *= Scalar;
((Standard_Real*)M)[2] *= Scalar;
((Standard_Real*)M)[3] *= Scalar;
}

inline gp_Mat2d gp_Mat2d::Powered (const Standard_Integer N) const
{
gp_Mat2d Mat2dN = *this;
Mat2dN.Power (N);
return Mat2dN;
}

inline void gp_Mat2d::Subtract (const gp_Mat2d& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] -= ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] -= ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] -= ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] -= ((Standard_Real*)O)[3];
}

inline gp_Mat2d gp_Mat2d::Subtracted (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] – ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] – ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] – ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] – ((Standard_Real*)O)[3];
return NewMat2d;
}

inline void gp_Mat2d::Transpose ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real Temp;
Temp = ((Standard_Real*)M)[1];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = Temp;
}

inline gp_Mat2d gp_Mat2d::Transposed () const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[2] = ((Standard_Real*)M)[1];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[2];
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3];
return NewMat2d;
}

inline gp_Mat2d operator* (const Standard_Real Scalar,
const gp_Mat2d& Mat2D)
{ return Mat2D.Multiplied (Scalar); }
# 293 “/usr/include/opencascade/gp_Mat2d.hxx” 2
# 33 “/usr/include/opencascade/gp_Trsf2d.hxx” 2

# 1 “/usr/include/opencascade/gp_XY.hxx” 1
# 40 “/usr/include/opencascade/gp_XY.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Mat2d;
# 52 “/usr/include/opencascade/gp_XY.hxx”
Handle_Standard_Type& gp_XY_Type_();
# 61 “/usr/include/opencascade/gp_XY.hxx”
class gp_XY {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_XY();

gp_XY(const Standard_Real X,const Standard_Real Y);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real X,const Standard_Real Y) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& X,Standard_Real& Y) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Modulus() const;

Standard_Real SquareModulus() const;

Standard_Boolean IsEqual(const gp_XY& Other,const Standard_Real Tolerance) const;

void Add(const gp_XY& Other) ;
void operator +=(const gp_XY& Other)
{
Add(Other);
}

gp_XY Added(const gp_XY& Other) const;
gp_XY operator +(const gp_XY& Other) const
{
return Added(Other);
}

Standard_Real Crossed(const gp_XY& Right) const;
Standard_Real operator ^(const gp_XY& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_XY& Right) const;

Standard_Real CrossSquareMagnitude(const gp_XY& Right) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_XY Divided(const Standard_Real Scalar) const;
gp_XY operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_XY& Other) const;
Standard_Real operator *(const gp_XY& Other) const
{
return Dot(Other);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Multiply(const gp_XY& Other) ;
void operator *=(const gp_XY& Other)
{
Multiply(Other);
}

void Multiply(const gp_Mat2d& Matrix) ;
void operator *=(const gp_Mat2d& Matrix)
{
Multiply(Matrix);
}

gp_XY Multiplied(const Standard_Real Scalar) const;
gp_XY operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

gp_XY Multiplied(const gp_XY& Other) const;

gp_XY Multiplied(const gp_Mat2d& Matrix) const;
gp_XY operator *(const gp_Mat2d& Matrix) const
{
return Multiplied(Matrix);
}

void Normalize() ;

gp_XY Normalized() const;

void Reverse() ;

gp_XY Reversed() const;
gp_XY operator -() const
{
return Reversed();
}

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const Standard_Real A2,const gp_XY& XY2) ;

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const Standard_Real A2,const gp_XY& XY2,const gp_XY& XY3) ;

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const gp_XY& XY2) ;

void SetLinearForm(const gp_XY& XY1,const gp_XY& XY2) ;

void Subtract(const gp_XY& Right) ;
void operator -=(const gp_XY& Right)
{
Subtract(Right);
}

gp_XY Subtracted(const gp_XY& Right) const;
gp_XY operator -(const gp_XY& Right) const
{
return Subtracted(Right);
}

Standard_Real _CSFDB_Getgp_XYx() const { return x; }
void _CSFDB_Setgp_XYx(const Standard_Real p) { x = p; }
Standard_Real _CSFDB_Getgp_XYy() const { return y; }
void _CSFDB_Setgp_XYy(const Standard_Real p) { y = p; }

friend Handle_Standard_Type& gp_XY_Type_();

protected:
# 303 “/usr/include/opencascade/gp_XY.hxx”
private:

Standard_Real x;
Standard_Real y;

};

# 1 “/usr/include/opencascade/gp_XY.lxx” 1
# 14 “/usr/include/opencascade/gp_XY.lxx”
inline gp_XY::gp_XY () { }

inline gp_XY::gp_XY (const Standard_Real X,
const Standard_Real Y) : x (X), y (Y) { }

inline void gp_XY::SetCoord (const Standard_Integer i,
const Standard_Real X)
{
if (i < 1 || i > 2) Standard_OutOfRange::Raise(__null);;
(&x)[i-1] = X;
}

inline void gp_XY::SetCoord (const Standard_Real X,
const Standard_Real Y)
{ x = X; y = Y; }

inline void gp_XY::SetX (const Standard_Real X)
{ x = X; }

inline void gp_XY::SetY (const Standard_Real Y)
{ y = Y; }

inline Standard_Real gp_XY::Coord (const Standard_Integer i) const
{
if (i < 1 || i > 2) Standard_OutOfRange::Raise(__null);;
return (&x)[i-1];
}

inline void gp_XY::Coord (Standard_Real& X,
Standard_Real& Y) const
{ X = x; Y = y; }

inline Standard_Real gp_XY::X () const
{ return x; }

inline Standard_Real gp_XY::Y () const
{ return y; }

inline Standard_Real gp_XY::Modulus () const
{
return sqrt (x * x + y * y);
}

inline Standard_Real gp_XY::SquareModulus () const
{
return x * x + y * y;
}

inline void gp_XY::Add (const gp_XY& Other) {
x += Other.x;
y += Other.y;
}

inline gp_XY gp_XY::Added (const gp_XY& Other) const {
return gp_XY(x + Other.X(),y + Other.Y());
}

inline Standard_Real gp_XY::Crossed (const gp_XY& Right) const {
return x * Right.y – y * Right.x;
}

inline Standard_Real gp_XY::CrossMagnitude (const gp_XY& Right) const
{
Standard_Real val = x * Right.y – y * Right.x;
if (val < 0) val = – val;
return val;
}

inline Standard_Real gp_XY::CrossSquareMagnitude (const gp_XY& Right) const {
Standard_Real Zresult = x * Right.y – y * Right.x;
return Zresult * Zresult;
}

inline void gp_XY::Divide (const Standard_Real Scalar)
{
x /= Scalar;
y /= Scalar;
}

inline gp_XY gp_XY::Divided (const Standard_Real Scalar) const {
return gp_XY(x / Scalar,y / Scalar);
}

inline Standard_Real gp_XY::Dot (const gp_XY& Other) const
{
return x * Other.x + y * Other.y;
}

inline void gp_XY::Multiply (const Standard_Real Scalar)
{
x *= Scalar;
y *= Scalar;
}

inline void gp_XY::Multiply (const gp_XY& Other)
{
x *= Other.x;
y *= Other.y;
}

inline void gp_XY::Multiply (const gp_Mat2d& Matrix)
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
Standard_Real Xresult = ((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y;
y = ((Standard_Real*)M)[2] * x + ((Standard_Real*)M)[3] * y;
x = Xresult;
}

inline gp_XY gp_XY::Multiplied (const Standard_Real Scalar) const {
return gp_XY(x * Scalar,y * Scalar);
}

inline gp_XY gp_XY::Multiplied (const gp_XY& Other) const {
return(gp_XY(x * Other.X(),y * Other.Y()));
}

inline gp_XY gp_XY::Multiplied (const gp_Mat2d& Matrix) const
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
return gp_XY (((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y,
((Standard_Real*)M)[2] * x + ((Standard_Real*)M)[3] * y);
}

inline void gp_XY::Normalize ()
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
x = x / D; y = y / D;
}

inline gp_XY gp_XY::Normalized () const
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
return gp_XY (x / D, y / D);
}

inline void gp_XY::Reverse ()
{ x = – x; y = – y; }

inline gp_XY gp_XY::Reversed () const
{
gp_XY Coord2D = *this;
Coord2D.Reverse();
return Coord2D;
}

inline void gp_XY::SetLinearForm (const Standard_Real L,
const gp_XY& Left,
const Standard_Real R,
const gp_XY& Right) {
x = L * Left.x + R * Right.x;
y = L * Left.y + R * Right.y;
}

inline void gp_XY::SetLinearForm (const Standard_Real L,
const gp_XY& Left,
const gp_XY& Right) {
x = L * Left.x + Right.x;
y = L * Left.y + Right.y;
}

inline void gp_XY::SetLinearForm (const gp_XY& Left,
const gp_XY& Right) {
x = Left.x + Right.x;
y = Left.y + Right.y;
}

inline void gp_XY::SetLinearForm (const Standard_Real A1,
const gp_XY& XY1,
const Standard_Real A2,
const gp_XY& XY2,
const gp_XY& XY3) {
x = A1 * XY1.x + A2 * XY2.x + XY3.x;
y = A1 * XY1.y + A2 * XY2.y + XY3.y;
}

inline void gp_XY::Subtract (const gp_XY& Right)
{
x -= Right.x;
y -= Right.y;
}

inline gp_XY gp_XY::Subtracted (const gp_XY& Right) const
{
gp_XY Coord2D = *this;
Coord2D.Subtract(Right);
return Coord2D;
}

inline gp_XY operator* (const gp_Mat2d& Matrix,
const gp_XY& Coord1) {
return Coord1.Multiplied(Matrix);
}

inline gp_XY operator* (const Standard_Real Scalar,
const gp_XY& Coord1) {
return Coord1.Multiplied(Scalar);
}
# 319 “/usr/include/opencascade/gp_XY.hxx” 2
# 36 “/usr/include/opencascade/gp_Trsf2d.hxx” 2
# 49 “/usr/include/opencascade/gp_Trsf2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_GTrsf2d;
class gp_Trsf;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Vec2d;
class gp_XY;
class gp_Mat2d;
# 67 “/usr/include/opencascade/gp_Trsf2d.hxx”
Handle_Standard_Type& gp_Trsf2d_Type_();
# 82 “/usr/include/opencascade/gp_Trsf2d.hxx”
class gp_Trsf2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Trsf2d();

gp_Trsf2d(const gp_Trsf& T);

void SetMirror(const gp_Pnt2d& P) ;

void SetMirror(const gp_Ax2d& A) ;

void SetRotation(const gp_Pnt2d& P,const Standard_Real Ang) ;

void SetScale(const gp_Pnt2d& P,const Standard_Real S) ;

void SetTransformation(const gp_Ax2d& FromSystem1,const gp_Ax2d& ToSystem2) ;

void SetTransformation(const gp_Ax2d& ToSystem) ;

void SetTranslation(const gp_Vec2d& V) ;

void SetTranslation(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

void SetTranslationPart(const gp_Vec2d& V) ;

void SetScaleFactor(const Standard_Real S) ;

Standard_Boolean IsNegative() const;

gp_TrsfForm Form() const;

Standard_Real ScaleFactor() const;

const gp_XY& TranslationPart() const;

gp_Mat2d VectorialPart() const;

const gp_Mat2d& HVectorialPart() const;

Standard_Real RotationPart() const;

Standard_Real Value(const Standard_Integer Row,const Standard_Integer Col) const;

void Invert() ;

gp_Trsf2d Inverted() const;

gp_Trsf2d Multiplied(const gp_Trsf2d& T) const;
gp_Trsf2d operator *(const gp_Trsf2d& T) const
{
return Multiplied(T);
}
# 213 “/usr/include/opencascade/gp_Trsf2d.hxx”
void Multiply(const gp_Trsf2d& T) ;
void operator *=(const gp_Trsf2d& T)
{
Multiply(T);
}

void PreMultiply(const gp_Trsf2d& T) ;

void Power(const Standard_Integer N) ;

gp_Trsf2d Powered(const Standard_Integer N) ;

void Transforms(Standard_Real& X,Standard_Real& Y) const;

void Transforms(gp_XY& Coord) const;
Standard_Real _CSFDB_Getgp_Trsf2dscale() const { return scale; }
void _CSFDB_Setgp_Trsf2dscale(const Standard_Real p) { scale = p; }
gp_TrsfForm _CSFDB_Getgp_Trsf2dshape() const { return shape; }
void _CSFDB_Setgp_Trsf2dshape(const gp_TrsfForm p) { shape = p; }
const gp_Mat2d& _CSFDB_Getgp_Trsf2dmatrix() const { return matrix; }
const gp_XY& _CSFDB_Getgp_Trsf2dloc() const { return loc; }

friend class gp_GTrsf2d;

friend Handle_Standard_Type& gp_Trsf2d_Type_();

protected:
# 262 “/usr/include/opencascade/gp_Trsf2d.hxx”
private:

Standard_Real scale;
gp_TrsfForm shape;
gp_Mat2d matrix;
gp_XY loc;

};

# 1 “/usr/include/opencascade/gp_Trsf2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Trsf.hxx” 1
# 4 “/usr/include/opencascade/gp_Trsf2d.lxx” 2
# 1 “/usr/include/opencascade/gp_Pnt2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Pnt2d.hxx”
class Standard_OutOfRange;
class gp_XY;
class gp_Ax2d;
class gp_Trsf2d;
class gp_Vec2d;
# 57 “/usr/include/opencascade/gp_Pnt2d.hxx”
Handle_Standard_Type& gp_Pnt2d_Type_();

class gp_Pnt2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Pnt2d();

gp_Pnt2d(const gp_XY& Coord);

gp_Pnt2d(const Standard_Real Xp,const Standard_Real Yp);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xp,const Standard_Real Yp) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xp,Standard_Real& Yp) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

const gp_XY& Coord() const;

gp_XY& ChangeCoord() ;

Standard_Boolean IsEqual(const gp_Pnt2d& Other,const Standard_Real LinearTolerance) const;

Standard_Real Distance(const gp_Pnt2d& Other) const;

Standard_Real SquareDistance(const gp_Pnt2d& Other) const;

void Mirror(const gp_Pnt2d& P) ;

gp_Pnt2d Mirrored(const gp_Pnt2d& P) const;

void Mirror(const gp_Ax2d& A) ;

gp_Pnt2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const gp_Pnt2d& P,const Standard_Real Ang) ;

gp_Pnt2d Rotated(const gp_Pnt2d& P,const Standard_Real Ang) const;

void Scale(const gp_Pnt2d& P,const Standard_Real S) ;

gp_Pnt2d Scaled(const gp_Pnt2d& P,const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Pnt2d Transformed(const gp_Trsf2d& T) const;

void Translate(const gp_Vec2d& V) ;

gp_Pnt2d Translated(const gp_Vec2d& V) const;

void Translate(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

gp_Pnt2d Translated(const gp_Pnt2d& P1,const gp_Pnt2d& P2) const;
const gp_XY& _CSFDB_Getgp_Pnt2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Pnt2d_Type_();

protected:
# 190 “/usr/include/opencascade/gp_Pnt2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Pnt2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Vec2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Vec2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_VectorWithNullMagnitude;
class gp_Dir2d;
class gp_XY;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Trsf2d;
# 60 “/usr/include/opencascade/gp_Vec2d.hxx”
Handle_Standard_Type& gp_Vec2d_Type_();

class gp_Vec2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Vec2d();

gp_Vec2d(const gp_Dir2d& V);

gp_Vec2d(const gp_XY& Coord);

gp_Vec2d(const Standard_Real Xv,const Standard_Real Yv);

gp_Vec2d(const gp_Pnt2d& P1,const gp_Pnt2d& P2);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

Standard_Boolean IsEqual(const gp_Vec2d& Other,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;
# 154 “/usr/include/opencascade/gp_Vec2d.hxx”
Standard_Real Angle(const gp_Vec2d& Other) const;

Standard_Real Magnitude() const;

Standard_Real SquareMagnitude() const;

void Add(const gp_Vec2d& Other) ;
void operator +=(const gp_Vec2d& Other)
{
Add(Other);
}

gp_Vec2d Added(const gp_Vec2d& Other) const;
gp_Vec2d operator +(const gp_Vec2d& Other) const
{
return Added(Other);
}

Standard_Real Crossed(const gp_Vec2d& Right) const;
Standard_Real operator ^(const gp_Vec2d& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_Vec2d& Right) const;

Standard_Real CrossSquareMagnitude(const gp_Vec2d& Right) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Vec2d Divided(const Standard_Real Scalar) const;
gp_Vec2d operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_Vec2d& Other) const;
Standard_Real operator *(const gp_Vec2d& Other) const
{
return Dot(Other);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

gp_Vec2d Multiplied(const Standard_Real Scalar) const;
gp_Vec2d operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Normalize() ;

gp_Vec2d Normalized() const;

void Reverse() ;

gp_Vec2d Reversed() const;
gp_Vec2d operator -() const
{
return Reversed();
}

void Subtract(const gp_Vec2d& Right) ;
void operator -=(const gp_Vec2d& Right)
{
Subtract(Right);
}

gp_Vec2d Subtracted(const gp_Vec2d& Right) const;
gp_Vec2d operator -(const gp_Vec2d& Right) const
{
return Subtracted(Right);
}

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const Standard_Real A2,const gp_Vec2d& V2,const gp_Vec2d& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const Standard_Real A2,const gp_Vec2d& V2) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const gp_Vec2d& V2) ;

void SetLinearForm(const gp_Vec2d& Left,const gp_Vec2d& Right) ;

void Mirror(const gp_Vec2d& V) ;
# 281 “/usr/include/opencascade/gp_Vec2d.hxx”
gp_Vec2d Mirrored(const gp_Vec2d& V) const;

void Mirror(const gp_Ax2d& A1) ;

gp_Vec2d Mirrored(const gp_Ax2d& A1) const;

void Rotate(const Standard_Real Ang) ;

gp_Vec2d Rotated(const Standard_Real Ang) const;

void Scale(const Standard_Real S) ;

gp_Vec2d Scaled(const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Vec2d Transformed(const gp_Trsf2d& T) const;
const gp_XY& _CSFDB_Getgp_Vec2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Vec2d_Type_();

protected:
# 325 “/usr/include/opencascade/gp_Vec2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Vec2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Dir2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Dir2d.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_Vec2d;
class gp_XY;
class gp_Ax2d;
class gp_Trsf2d;
# 59 “/usr/include/opencascade/gp_Dir2d.hxx”
Handle_Standard_Type& gp_Dir2d_Type_();
# 69 “/usr/include/opencascade/gp_Dir2d.hxx”
class gp_Dir2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Dir2d();

gp_Dir2d(const gp_Vec2d& V);

gp_Dir2d(const gp_XY& Coord);

gp_Dir2d(const Standard_Real Xv,const Standard_Real Yv);
# 112 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;
# 128 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetCoord(const Standard_Real Xv,const Standard_Real Yv) ;
# 142 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetX(const Standard_Real X) ;
# 156 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetY(const Standard_Real Y) ;
# 171 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

Standard_Boolean IsEqual(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Dir2d& Other) const;

Standard_Real Crossed(const gp_Dir2d& Right) const;
Standard_Real operator ^(const gp_Dir2d& Right) const
{
return Crossed(Right);
}

Standard_Real Dot(const gp_Dir2d& Other) const;
Standard_Real operator *(const gp_Dir2d& Other) const
{
return Dot(Other);
}

void Reverse() ;

gp_Dir2d Reversed() const;
gp_Dir2d operator -() const
{
return Reversed();
}

void Mirror(const gp_Dir2d& V) ;

gp_Dir2d Mirrored(const gp_Dir2d& V) const;

void Mirror(const gp_Ax2d& A) ;

gp_Dir2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const Standard_Real Ang) ;

gp_Dir2d Rotated(const Standard_Real Ang) const;

void Transform(const gp_Trsf2d& T) ;

gp_Dir2d Transformed(const gp_Trsf2d& T) const;
const gp_XY& _CSFDB_Getgp_Dir2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Dir2d_Type_();

protected:
# 290 “/usr/include/opencascade/gp_Dir2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Dir2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Ax2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Ax2d.hxx”
class gp_Pnt2d;
class gp_Dir2d;
class gp_Trsf2d;
class gp_Vec2d;
# 56 “/usr/include/opencascade/gp_Ax2d.hxx”
Handle_Standard_Type& gp_Ax2d_Type_();
# 77 “/usr/include/opencascade/gp_Ax2d.hxx”
class gp_Ax2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Ax2d();

gp_Ax2d(const gp_Pnt2d& P,const gp_Dir2d& V);

void SetLocation(const gp_Pnt2d& Locat) ;

void SetDirection(const gp_Dir2d& V) ;

const gp_Pnt2d& Location() const;

const gp_Dir2d& Direction() const;
# 119 “/usr/include/opencascade/gp_Ax2d.hxx”
Standard_Boolean IsCoaxial(const gp_Ax2d& Other,const Standard_Real AngularTolerance,const Standard_Real LinearTolerance) const;

Standard_Boolean IsNormal(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Ax2d& Other) const;

void Reverse() ;

gp_Ax2d Reversed() const;

void Mirror(const gp_Pnt2d& P) ;

gp_Ax2d Mirrored(const gp_Pnt2d& P) const;

void Mirror(const gp_Ax2d& A) ;

gp_Ax2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const gp_Pnt2d& P,const Standard_Real Ang) ;

gp_Ax2d Rotated(const gp_Pnt2d& P,const Standard_Real Ang) const;

void Scale(const gp_Pnt2d& P,const Standard_Real S) ;

gp_Ax2d Scaled(const gp_Pnt2d& P,const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Ax2d Transformed(const gp_Trsf2d& T) const;

void Translate(const gp_Vec2d& V) ;

gp_Ax2d Translated(const gp_Vec2d& V) const;

void Translate(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

gp_Ax2d Translated(const gp_Pnt2d& P1,const gp_Pnt2d& P2) const;
const gp_Pnt2d& _CSFDB_Getgp_Ax2dloc() const { return loc; }
const gp_Dir2d& _CSFDB_Getgp_Ax2dvdir() const { return vdir; }

friend Handle_Standard_Type& gp_Ax2d_Type_();

protected:
# 213 “/usr/include/opencascade/gp_Ax2d.hxx”
private:

gp_Pnt2d loc;
gp_Dir2d vdir;

};

# 1 “/usr/include/opencascade/gp_Ax2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Ax2d.hxx” 1
# 6 “/usr/include/opencascade/gp_Ax2d.lxx” 2

inline gp_Ax2d::gp_Ax2d()
{ }

inline gp_Ax2d::gp_Ax2d (const gp_Pnt2d& P,
const gp_Dir2d& V) : loc(P), vdir(V)
{ }

inline void gp_Ax2d::SetLocation(const gp_Pnt2d& P)
{ loc = P; }

inline void gp_Ax2d::SetDirection(const gp_Dir2d& V)
{ vdir = V; }

inline const gp_Pnt2d& gp_Ax2d::Location () const
{ return loc; }

inline const gp_Dir2d& gp_Ax2d::Direction () const
{ return vdir; }

inline Standard_Boolean gp_Ax2d::IsNormal
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsNormal(Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax2d::IsOpposite
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsOpposite (Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax2d::IsParallel
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsParallel(Other.vdir, AngularTolerance); }

inline Standard_Real gp_Ax2d::Angle (const gp_Ax2d& Other) const
{ return vdir.Angle (Other.vdir); }

inline void gp_Ax2d::Reverse()
{ vdir.Reverse(); }

inline gp_Ax2d gp_Ax2d::Reversed() const
{
gp_Ax2d Temp = *this;
Temp.Reverse ();
return Temp;
}

inline void gp_Ax2d::Rotate (const gp_Pnt2d& P,
const Standard_Real Ang)
{
loc.Rotate (P, Ang);
vdir.Rotate (Ang);
}

inline gp_Ax2d gp_Ax2d::Rotated (const gp_Pnt2d& P,
const Standard_Real Ang) const
{
gp_Ax2d A = *this;
A.Rotate (P, Ang);
return A;
}

inline gp_Ax2d gp_Ax2d::Scaled (const gp_Pnt2d& P,
const Standard_Real S) const
{
gp_Ax2d A = *this;
A.Scale (P, S);
return A;
}

inline void gp_Ax2d::Transform (const gp_Trsf2d& T)
{
loc.Transform (T);
vdir.Transform (T);
}

inline gp_Ax2d gp_Ax2d::Transformed (const gp_Trsf2d& T) const
{
gp_Ax2d A = *this;
A.Transform (T);
return A;
}

inline void gp_Ax2d::Translate (const gp_Vec2d& V)
{ loc.Translate (V); }

inline gp_Ax2d gp_Ax2d::Translated (const gp_Vec2d& V) const
{
gp_Ax2d A = *this;
(A.loc).Translate (V);
return A;
}

inline void gp_Ax2d::Translate (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{ loc.Translate (P1,P2); }

inline gp_Ax2d gp_Ax2d::Translated (const gp_Pnt2d& P1,
const gp_Pnt2d& P2) const
{
gp_Ax2d A = *this;
(A.loc).Translate( gp_Vec2d (P1, P2));
return A;
}
# 229 “/usr/include/opencascade/gp_Ax2d.hxx” 2
# 8 “/usr/include/opencascade/gp_Dir2d.lxx” 2
# 1 “/usr/include/opencascade/gp_Trsf2d.hxx” 1
# 9 “/usr/include/opencascade/gp_Dir2d.lxx” 2

inline gp_Dir2d::gp_Dir2d()
{ coord.SetCoord (1.0, 0.0); }

inline gp_Dir2d::gp_Dir2d (const gp_Vec2d& V)
{
const gp_XY& XY = V.XY();
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline gp_Dir2d::gp_Dir2d (const gp_XY& XY)
{
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline gp_Dir2d::gp_Dir2d (const Standard_Real Xv,
const Standard_Real Yv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
}

inline void gp_Dir2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
if (Index < 1 || Index > 2) Standard_OutOfRange::Raise(” “);;
if (Index == 1) X = Xi;
else Y = Xi;
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetCoord (const Standard_Real Xv,
const Standard_Real Yv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
}

inline void gp_Dir2d::SetX (const Standard_Real X)
{
Standard_Real Y = coord.Y();
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetY (const Standard_Real Y)
{
Standard_Real X = coord.X();
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetXY (const gp_XY& XY)
{
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline Standard_Real gp_Dir2d::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Dir2d::Coord(Standard_Real& Xv, Standard_Real& Yv) const
{ coord.Coord (Xv, Yv); }

inline Standard_Real gp_Dir2d::X() const
{ return coord.X() ; }

inline Standard_Real gp_Dir2d::Y() const
{ return coord.Y() ; }

inline const gp_XY& gp_Dir2d::XY () const
{ return coord; }

inline Standard_Boolean gp_Dir2d::IsEqual
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsNormal
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
Ang = Standard_PI / 2.0 – Ang;
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsOpposite
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsParallel
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Real gp_Dir2d::Crossed (const gp_Dir2d& Right) const
{ return coord.Crossed (Right.coord); }

inline Standard_Real gp_Dir2d::Dot (const gp_Dir2d& Other) const
{ return coord.Dot (Other.coord); }

inline void gp_Dir2d::Reverse()
{ coord.Reverse(); }

inline gp_Dir2d gp_Dir2d::Reversed() const
{
gp_Dir2d V = *this;
V.coord.Reverse ();
return V;
}

inline void gp_Dir2d::Rotate (const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (gp_Pnt2d (0.0, 0.0), Ang);
coord.Multiply (T.HVectorialPart());
}

inline gp_Dir2d gp_Dir2d::Rotated (const Standard_Real Ang) const
{
gp_Dir2d V = *this;
V.Rotate (Ang);
return V;
}

inline gp_Dir2d gp_Dir2d::Transformed (const gp_Trsf2d& T) const
{
gp_Dir2d V = *this;
V.Transform (T);
return V;
}
# 305 “/usr/include/opencascade/gp_Dir2d.hxx” 2
# 6 “/usr/include/opencascade/gp_Vec2d.lxx” 2

# 1 “/usr/include/opencascade/gp_Pnt2d.hxx” 1
# 8 “/usr/include/opencascade/gp_Vec2d.lxx” 2

inline gp_Vec2d::gp_Vec2d()
{}

inline gp_Vec2d::gp_Vec2d (const gp_Dir2d& V)
{ coord = V.XY(); }

inline gp_Vec2d::gp_Vec2d (const gp_XY& Coord) : coord(Coord)
{}

inline gp_Vec2d::gp_Vec2d (const Standard_Real Xv,
const Standard_Real Yv) : coord (Xv, Yv)
{ }

inline gp_Vec2d::gp_Vec2d (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{ coord = P2.XY().Subtracted (P1.XY()); }

inline void gp_Vec2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Vec2d::SetCoord (const Standard_Real Xv,
const Standard_Real Yv)
{ coord.SetCoord (Xv, Yv); }

inline void gp_Vec2d::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Vec2d::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Vec2d::SetXY (const gp_XY& Coord)
{ coord = Coord; }

inline Standard_Real gp_Vec2d::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Vec2d::Coord(Standard_Real& Xv,
Standard_Real& Yv) const
{ coord.Coord(Xv, Yv); }

inline Standard_Real gp_Vec2d::X() const
{ return coord.X(); }

inline Standard_Real gp_Vec2d::Y() const
{ return coord.Y(); }

inline const gp_XY& gp_Vec2d::XY () const
{ return coord; }

inline Standard_Boolean gp_Vec2d::IsNormal
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
Ang = Standard_PI / 2.0 – Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec2d::IsOpposite
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec2d::IsParallel
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Real gp_Vec2d::Magnitude() const
{ return coord.Modulus(); }

inline Standard_Real gp_Vec2d::SquareMagnitude() const
{ return coord.SquareModulus(); }

inline void gp_Vec2d::Add (const gp_Vec2d& Other)
{ coord.Add (Other.coord); }

inline gp_Vec2d gp_Vec2d::Added (const gp_Vec2d& Other) const
{
gp_Vec2d V = *this;
V.coord.Add (Other.coord);
return V;
}

inline Standard_Real gp_Vec2d::Crossed (const gp_Vec2d& Right) const
{ return coord.Crossed (Right.coord); }

inline Standard_Real gp_Vec2d::CrossMagnitude (const gp_Vec2d& Right) const
{ return coord.CrossMagnitude (Right.coord); }

inline Standard_Real gp_Vec2d::CrossSquareMagnitude
(const gp_Vec2d& Right) const
{ return coord.CrossSquareMagnitude (Right.coord); }

inline void gp_Vec2d::Divide (const Standard_Real Scalar)
{ coord.Divide (Scalar); }

inline gp_Vec2d gp_Vec2d::Divided (const Standard_Real Scalar) const
{
gp_Vec2d V = *this;
V.coord.Divide(Scalar);
return V;
}

inline Standard_Real gp_Vec2d::Dot (const gp_Vec2d& Other) const
{ return coord.Dot (Other.coord); }

inline void gp_Vec2d::Multiply (const Standard_Real Scalar)
{ coord.Multiply (Scalar); }

inline gp_Vec2d gp_Vec2d::Multiplied (const Standard_Real Scalar) const
{
gp_Vec2d V = *this;
V.coord.Multiply(Scalar);
return V;
}

inline void gp_Vec2d::Normalize()
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide (D);
}

inline gp_Vec2d gp_Vec2d::Normalized() const
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
gp_Vec2d V = *this;
V.coord.Divide (D);
return V;
}

inline void gp_Vec2d::Reverse()
{ coord.Reverse(); }

inline gp_Vec2d gp_Vec2d::Reversed() const
{
gp_Vec2d V = *this;
V.coord.Reverse();
return V;
}

inline void gp_Vec2d::Subtract (const gp_Vec2d& Right)
{ coord.Subtract (Right.coord); }

inline gp_Vec2d gp_Vec2d::Subtracted (const gp_Vec2d& Right) const
{
gp_Vec2d V = *this;
V.coord.Subtract (Right.coord);
return V;
}

inline void gp_Vec2d::SetLinearForm (const Standard_Real L,
const gp_Vec2d& Left,
const Standard_Real R,
const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real L,
const gp_Vec2d& Left,
const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const gp_Vec2d& Left,
const gp_Vec2d& Right)
{ coord.SetLinearForm (Left.coord, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real A1,
const gp_Vec2d& V1,
const Standard_Real A2,
const gp_Vec2d& V2,
const gp_Vec2d& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }

inline void gp_Vec2d::Rotate (const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (gp_Pnt2d (0.0, 0.0), Ang);
coord.Multiply (T.VectorialPart ());
}

inline gp_Vec2d gp_Vec2d::Rotated (const Standard_Real Ang) const
{
gp_Vec2d V = *this;
V.Rotate (Ang);
return V;
}

inline void gp_Vec2d::Scale (const Standard_Real S)
{ coord.Multiply (S); }

inline gp_Vec2d gp_Vec2d::Scaled (const Standard_Real S) const
{
gp_Vec2d V = *this;
V.coord.Multiply (S);
return V;
}

inline gp_Vec2d gp_Vec2d::Transformed (const gp_Trsf2d& T) const
{
gp_Vec2d V = *this;
V.Transform(T);
return V;
}

inline gp_Vec2d operator* (const Standard_Real Scalar,
const gp_Vec2d& V)
{ return V.Multiplied(Scalar); }
# 340 “/usr/include/opencascade/gp_Vec2d.hxx” 2
# 7 “/usr/include/opencascade/gp_Pnt2d.lxx” 2

inline gp_Pnt2d::gp_Pnt2d (const gp_XY& Coordinates) : coord (Coordinates)
{ }

inline gp_Pnt2d::gp_Pnt2d (const Standard_Real Xp,
const Standard_Real Yp) : coord (Xp, Yp)
{ }

inline gp_Pnt2d::gp_Pnt2d() { }

inline Standard_Real gp_Pnt2d::Coord(const Standard_Integer Index) const { return coord.Coord(Index); }

inline void gp_Pnt2d::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Pnt2d::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Pnt2d::SetXY (const gp_XY& Coordinates)
{ coord = Coordinates; }

inline void gp_Pnt2d::SetCoord (const Standard_Real Xp,
const Standard_Real Yp)
{ coord.SetCoord (Xp, Yp);}

inline void gp_Pnt2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Pnt2d::Coord (Standard_Real& Xp,
Standard_Real& Yp) const
{ coord.Coord (Xp, Yp); }

inline Standard_Real gp_Pnt2d::X() const
{ return coord.X(); }

inline Standard_Real gp_Pnt2d::Y() const
{ return coord.Y(); }

inline const gp_XY& gp_Pnt2d::XY () const
{ return coord; }

inline const gp_XY& gp_Pnt2d::Coord () const
{ return coord; }

inline gp_XY& gp_Pnt2d::ChangeCoord ()
{ return coord; }

inline Standard_Boolean gp_Pnt2d::IsEqual
(const gp_Pnt2d& Other,
const Standard_Real LinearTolerance) const
{ return Distance (Other) <= LinearTolerance; }

inline Standard_Real gp_Pnt2d::Distance (const gp_Pnt2d& Other) const
{
const gp_XY& XY = Other.coord;
Standard_Real X = coord.X() – XY.X();
Standard_Real Y = coord.Y() – XY.Y();
return sqrt (X * X + Y * Y);
}

inline Standard_Real gp_Pnt2d::SquareDistance (const gp_Pnt2d& Other) const
{
const gp_XY& XY = Other.coord;
Standard_Real X = coord.X() – XY.X();
Standard_Real Y = coord.Y() – XY.Y();
return (X * X + Y * Y);
}

inline void gp_Pnt2d::Rotate (const gp_Pnt2d& P,
const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (P, Ang);
T.Transforms (coord);
}

inline gp_Pnt2d gp_Pnt2d::Rotated (const gp_Pnt2d& P,
const Standard_Real Ang) const
{
gp_Pnt2d Pres = *this;
Pres.Rotate (P, Ang);
return Pres;
}

inline void gp_Pnt2d::Scale (const gp_Pnt2d& P,
const Standard_Real S)
{
gp_XY XY = P.coord;
XY.Multiply (1.0 – S);
coord.Multiply (S);
coord.Add (XY);
}

inline gp_Pnt2d gp_Pnt2d::Scaled (const gp_Pnt2d& P,
const Standard_Real S) const
{
gp_Pnt2d Pres = *this;
Pres.Scale (P, S);
return Pres;
}

inline gp_Pnt2d gp_Pnt2d::Transformed (const gp_Trsf2d& T) const
{
gp_Pnt2d Pres = *this;
Pres.Transform (T);
return Pres;
}

inline void gp_Pnt2d::Translate (const gp_Vec2d& V)
{ coord.Add (V.XY()); }

inline gp_Pnt2d gp_Pnt2d::Translated (const gp_Vec2d& V) const
{
gp_Pnt2d P = *this;
P.coord.Add (V.XY ());
return P;
}

inline void gp_Pnt2d::Translate (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{
coord.Add (P2.coord);
coord.Subtract (P1.coord);
}

inline gp_Pnt2d gp_Pnt2d::Translated (const gp_Pnt2d& P1,
const gp_Pnt2d& P2) const
{
gp_Pnt2d P = *this;
P.Translate (P1, P2);
return P;
}
# 205 “/usr/include/opencascade/gp_Pnt2d.hxx” 2
# 5 “/usr/include/opencascade/gp_Trsf2d.lxx” 2

inline gp_Trsf2d::gp_Trsf2d () {
shape = gp_Identity;
scale = 1.0;
matrix.SetIdentity ();
loc.SetCoord (0.0, 0.0);
}

inline gp_Trsf2d::gp_Trsf2d (const gp_Trsf& T) :
scale(T.ScaleFactor()),
shape(T.Form()),
loc(T.TranslationPart().X(),T.TranslationPart().Y())
{
const gp_Mat& M = T.HVectorialPart();
matrix(1,1) = M(1,1);
matrix(1,2) = M(1,2);
matrix(2,1) = M(2,1);
matrix(2,2) = M(2,2);
}

inline void gp_Trsf2d::SetMirror(const gp_Pnt2d& P)
{
shape = gp_PntMirror;
scale = -1.0;
matrix.SetIdentity ();
loc = P.XY();
loc.Multiply (2.0);
}

inline void gp_Trsf2d::SetRotation (const gp_Pnt2d& P,
const Standard_Real Ang)
{
shape = gp_Rotation;
scale = 1.0;
loc = P.XY ();
loc.Reverse ();
matrix.SetRotation (Ang);
loc.Multiply (matrix);
loc.Add (P.XY());
}

inline void gp_Trsf2d::SetScale (const gp_Pnt2d& P,
const Standard_Real S)
{
shape = gp_Scale;
scale = S;
matrix.SetIdentity ();
loc = P.XY ();
loc.Multiply (1.0 – S);
}

inline void gp_Trsf2d::SetTranslation(const gp_Vec2d& V)
{
shape = gp_Translation;
scale = 1.0;
matrix.SetIdentity ();
loc = V.XY ();
}

inline void gp_Trsf2d::SetTranslation (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{
shape = gp_Translation;
scale = 1.0;
matrix.SetIdentity ();
loc = (P2.XY()).Subtracted (P1.XY());
}

inline Standard_Boolean gp_Trsf2d::IsNegative() const
{ return (scale < 0.0); }

inline const gp_XY& gp_Trsf2d::TranslationPart () const
{ return loc; }

inline const gp_Mat2d& gp_Trsf2d::HVectorialPart () const
{ return matrix; }

inline Standard_Real gp_Trsf2d::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

if (Col < 3) return scale * matrix.Value (Row, Col);
else return loc.Coord (Row);
}

inline gp_TrsfForm gp_Trsf2d::Form() const
{ return shape; }

inline Standard_Real gp_Trsf2d::ScaleFactor() const
{ return scale; }

inline gp_Trsf2d gp_Trsf2d::Inverted() const
{
gp_Trsf2d T = *this;
T.Invert();
return T;
}

inline gp_Trsf2d gp_Trsf2d::Multiplied (const gp_Trsf2d& T) const {
gp_Trsf2d Tresult(*this);
Tresult.Multiply(T);
return Tresult;
}

inline gp_Trsf2d gp_Trsf2d::Powered (const Standard_Integer N)
{
gp_Trsf2d T = *this;
T.Power (N);
return T;
}

inline void gp_Trsf2d::Transforms (Standard_Real& X,
Standard_Real& Y) const
{
gp_XY Doublet (X, Y);
Doublet.Multiply (matrix);
if (scale != 1.0) Doublet.Multiply (scale);
Doublet.Add(loc);
Doublet.Coord (X, Y);
}

inline void gp_Trsf2d::Transforms (gp_XY& Coord) const
{
Coord.Multiply (matrix);
if (scale != 1.0) Coord.Multiply (scale);
Coord.Add(loc);
}
# 280 “/usr/include/opencascade/gp_Trsf2d.hxx” 2
# 8 “/usr/include/opencascade/gp_Trsf.lxx” 2
# 1 “/usr/include/opencascade/gp_Vec.hxx” 1
# 43 “/usr/include/opencascade/gp_Vec.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_VectorWithNullMagnitude;
class gp_Dir;
class gp_XYZ;
class gp_Pnt;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
# 62 “/usr/include/opencascade/gp_Vec.hxx”
Handle_Standard_Type& gp_Vec_Type_();

class gp_Vec {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Vec();

gp_Vec(const gp_Dir& V);

gp_Vec(const gp_XYZ& Coord);

gp_Vec(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv);

gp_Vec(const gp_Pnt& P1,const gp_Pnt& P2);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv,Standard_Real& Zv) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

Standard_Boolean IsEqual(const gp_Vec& Other,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Vec& Other) const;
# 174 “/usr/include/opencascade/gp_Vec.hxx”
Standard_Real AngleWithRef(const gp_Vec& Other,const gp_Vec& VRef) const;

Standard_Real Magnitude() const;

Standard_Real SquareMagnitude() const;

void Add(const gp_Vec& Other) ;
void operator +=(const gp_Vec& Other)
{
Add(Other);
}

gp_Vec Added(const gp_Vec& Other) const;
gp_Vec operator +(const gp_Vec& Other) const
{
return Added(Other);
}

void Subtract(const gp_Vec& Right) ;
void operator -=(const gp_Vec& Right)
{
Subtract(Right);
}

gp_Vec Subtracted(const gp_Vec& Right) const;
gp_Vec operator -(const gp_Vec& Right) const
{
return Subtracted(Right);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

gp_Vec Multiplied(const Standard_Real Scalar) const;
gp_Vec operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Vec Divided(const Standard_Real Scalar) const;
gp_Vec operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Cross(const gp_Vec& Right) ;
void operator ^=(const gp_Vec& Right)
{
Cross(Right);
}

gp_Vec Crossed(const gp_Vec& Right) const;
gp_Vec operator ^(const gp_Vec& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_Vec& Right) const;

Standard_Real CrossSquareMagnitude(const gp_Vec& Right) const;

void CrossCross(const gp_Vec& V1,const gp_Vec& V2) ;

gp_Vec CrossCrossed(const gp_Vec& V1,const gp_Vec& V2) const;

Standard_Real Dot(const gp_Vec& Other) const;
Standard_Real operator *(const gp_Vec& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_Vec& V1,const gp_Vec& V2) const;

void Normalize() ;

gp_Vec Normalized() const;

void Reverse() ;

gp_Vec Reversed() const;
gp_Vec operator -() const
{
return Reversed();
}

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const Standard_Real A3,const gp_Vec& V3,const gp_Vec& V4) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const Standard_Real A3,const gp_Vec& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const gp_Vec& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const gp_Vec& V2) ;

void SetLinearForm(const gp_Vec& V1,const gp_Vec& V2) ;

void Mirror(const gp_Vec& V) ;

gp_Vec Mirrored(const gp_Vec& V) const;

void Mirror(const gp_Ax1& A1) ;

gp_Vec Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Vec Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Vec Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const Standard_Real S) ;

gp_Vec Scaled(const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Vec Transformed(const gp_Trsf& T) const;
const gp_XYZ& _CSFDB_Getgp_Veccoord() const { return coord; }

friend Handle_Standard_Type& gp_Vec_Type_();

protected:
# 374 “/usr/include/opencascade/gp_Vec.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Vec.lxx” 1

# 1 “/usr/include/opencascade/gp_Dir.hxx” 1
# 43 “/usr/include/opencascade/gp_Dir.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_Vec;
class gp_XYZ;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
# 60 “/usr/include/opencascade/gp_Dir.hxx”
Handle_Standard_Type& gp_Dir_Type_();
# 70 “/usr/include/opencascade/gp_Dir.hxx”
class gp_Dir {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Dir();

gp_Dir(const gp_Vec& V);

gp_Dir(const gp_XYZ& Coord);

gp_Dir(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv);
# 117 “/usr/include/opencascade/gp_Dir.hxx”
void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv,Standard_Real& Zv) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

Standard_Boolean IsEqual(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Dir& Other) const;
# 179 “/usr/include/opencascade/gp_Dir.hxx”
Standard_Real AngleWithRef(const gp_Dir& Other,const gp_Dir& VRef) const;

void Cross(const gp_Dir& Right) ;
void operator ^=(const gp_Dir& Right)
{
Cross(Right);
}

gp_Dir Crossed(const gp_Dir& Right) const;
gp_Dir operator ^(const gp_Dir& Right) const
{
return Crossed(Right);
}

void CrossCross(const gp_Dir& V1,const gp_Dir& V2) ;
# 211 “/usr/include/opencascade/gp_Dir.hxx”
gp_Dir CrossCrossed(const gp_Dir& V1,const gp_Dir& V2) const;

Standard_Real Dot(const gp_Dir& Other) const;
Standard_Real operator *(const gp_Dir& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_Dir& V1,const gp_Dir& V2) const;

void Reverse() ;

gp_Dir Reversed() const;
gp_Dir operator -() const
{
return Reversed();
}

void Mirror(const gp_Dir& V) ;

gp_Dir Mirrored(const gp_Dir& V) const;

void Mirror(const gp_Ax1& A1) ;

gp_Dir Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Dir Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Dir Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Transform(const gp_Trsf& T) ;

gp_Dir Transformed(const gp_Trsf& T) const;
const gp_XYZ& _CSFDB_Getgp_Dircoord() const { return coord; }

friend Handle_Standard_Type& gp_Dir_Type_();

protected:
# 299 “/usr/include/opencascade/gp_Dir.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Dir.lxx” 1

# 1 “/usr/include/opencascade/gp_Vec.hxx” 1
# 4 “/usr/include/opencascade/gp_Dir.lxx” 2

inline gp_Dir::gp_Dir ()
{ coord.SetCoord (1.0, 0.0, 0.0); }

inline gp_Dir::gp_Dir (const gp_Vec& V)
{
const gp_XYZ& XYZ = V.XYZ();
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline gp_Dir::gp_Dir (const gp_XYZ& XYZ)
{
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline gp_Dir::gp_Dir (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv + Zv * Zv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
coord.SetZ(Zv / D);
}

inline void gp_Dir::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
Standard_Real Z = coord.Z();
if (Index < 1 || Index > 3) Standard_OutOfRange::Raise(” “);;
if (Index == 1) X = Xi;
else if (Index == 2) Y = Xi;
else Z = Xi;
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetCoord (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv) {
Standard_Real D = sqrt(Xv * Xv + Yv * Yv + Zv * Zv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
coord.SetZ(Zv / D);
}

inline void gp_Dir::SetX (const Standard_Real X)
{
Standard_Real Y = coord.Y();
Standard_Real Z = coord.Z();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetY (const Standard_Real Y)
{
Standard_Real Z = coord.Z();
Standard_Real X = coord.X();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetZ (const Standard_Real Z)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetXYZ (const gp_XYZ& XYZ)
{
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline Standard_Real gp_Dir::Coord (const Standard_Integer Index) const
{ return coord.Coord (Index);}

inline void gp_Dir::Coord (Standard_Real& Xv,
Standard_Real& Yv,
Standard_Real& Zv) const
{ coord.Coord (Xv, Yv, Zv); }

inline Standard_Real gp_Dir::X() const
{ return coord.X() ; }

inline Standard_Real gp_Dir::Y() const
{ return coord.Y() ; }

inline Standard_Real gp_Dir::Z() const
{ return coord.Z() ; }

inline const gp_XYZ& gp_Dir::XYZ () const
{ return coord; }

inline Standard_Boolean gp_Dir::IsEqual
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{ return Angle (Other) <= AngularTolerance; }

inline Standard_Boolean gp_Dir::IsNormal
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Standard_PI / 2.0 – Angle (Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir::IsOpposite
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{ return Standard_PI – Angle (Other) <= AngularTolerance; }

inline Standard_Boolean gp_Dir::IsParallel
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle (Other);
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline void gp_Dir::Cross (const gp_Dir& Right)
{
coord.Cross (Right.coord);
Standard_Real D = coord.Modulus ();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide (D);
}

inline gp_Dir gp_Dir::Crossed (const gp_Dir& Right) const
{
gp_Dir V = *this;
V.coord.Cross (Right.coord);
Standard_Real D = V.coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
V.coord.Divide (D);
return V;
}

inline void gp_Dir::CrossCross (const gp_Dir& V1,
const gp_Dir& V2)
{
coord.CrossCross (V1.coord, V2.coord);
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide(D);
}

inline gp_Dir gp_Dir::CrossCrossed (const gp_Dir& V1,
const gp_Dir& V2) const
{
gp_Dir V = *this;
(V.coord).CrossCross (V1.coord, V2.coord);
Standard_Real D = V.coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
V.coord.Divide(D);
return V;
}

inline Standard_Real gp_Dir::Dot (const gp_Dir& Other) const
{ return coord.Dot (Other.coord); }

inline Standard_Real gp_Dir::DotCross (const gp_Dir& V1,
const gp_Dir& V2) const
{ return coord.Dot (V1.coord.Crossed (V2.coord)); }

inline void gp_Dir::Reverse ()
{ coord.Reverse(); }

inline gp_Dir gp_Dir::Reversed () const {
gp_Dir V = *this;
V.coord.Reverse ();
return V;
}

inline void gp_Dir::Rotate (const gp_Ax1& A1, const Standard_Real Ang)
{
gp_Trsf T;
T.SetRotation (A1, Ang);
coord.Multiply (T.HVectorialPart ());
}

inline gp_Dir gp_Dir::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Dir V = *this;
V.Rotate (A1, Ang);
return V;
}

inline gp_Dir gp_Dir::Transformed (const gp_Trsf& T) const
{
gp_Dir V = *this;
V.Transform (T);
return V;
}
# 314 “/usr/include/opencascade/gp_Dir.hxx” 2
# 7 “/usr/include/opencascade/gp_Vec.lxx” 2
# 1 “/usr/include/opencascade/gp_Pnt.hxx” 1
# 43 “/usr/include/opencascade/gp_Pnt.hxx”
class Standard_OutOfRange;
class gp_XYZ;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
class gp_Vec;
# 58 “/usr/include/opencascade/gp_Pnt.hxx”
Handle_Standard_Type& gp_Pnt_Type_();

class gp_Pnt {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Pnt();

gp_Pnt(const gp_XYZ& Coord);

gp_Pnt(const Standard_Real Xp,const Standard_Real Yp,const Standard_Real Zp);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xp,const Standard_Real Yp,const Standard_Real Zp) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xp,Standard_Real& Yp,Standard_Real& Zp) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

const gp_XYZ& Coord() const;

gp_XYZ& ChangeCoord() ;

void BaryCenter(const Standard_Real Alpha,const gp_Pnt& P,const Standard_Real Beta) ;

Standard_Boolean IsEqual(const gp_Pnt& Other,const Standard_Real LinearTolerance) const;

Standard_Real Distance(const gp_Pnt& Other) const;

Standard_Real SquareDistance(const gp_Pnt& Other) const;

void Mirror(const gp_Pnt& P) ;

gp_Pnt Mirrored(const gp_Pnt& P) const;

void Mirror(const gp_Ax1& A1) ;

gp_Pnt Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Pnt Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Pnt Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const gp_Pnt& P,const Standard_Real S) ;

gp_Pnt Scaled(const gp_Pnt& P,const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Pnt Transformed(const gp_Trsf& T) const;

void Translate(const gp_Vec& V) ;

gp_Pnt Translated(const gp_Vec& V) const;

void Translate(const gp_Pnt& P1,const gp_Pnt& P2) ;

gp_Pnt Translated(const gp_Pnt& P1,const gp_Pnt& P2) const;
const gp_XYZ& _CSFDB_Getgp_Pntcoord() const { return coord; }

friend Handle_Standard_Type& gp_Pnt_Type_();

protected:
# 208 “/usr/include/opencascade/gp_Pnt.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Pnt.lxx” 1
# 9 “/usr/include/opencascade/gp_Pnt.lxx”
inline gp_Pnt::gp_Pnt() { }

inline gp_Pnt::gp_Pnt (const gp_XYZ& Coordinates) : coord (Coordinates)
{ }

inline gp_Pnt::gp_Pnt (const Standard_Real Xp,
const Standard_Real Yp,
const Standard_Real Zp) : coord(Xp, Yp,Zp)
{ }

inline void gp_Pnt::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Pnt::SetCoord (const Standard_Real Xp,
const Standard_Real Yp,
const Standard_Real Zp) {
coord.SetCoord (Xp, Yp, Zp);
}

inline void gp_Pnt::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Pnt::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Pnt::SetZ (const Standard_Real Z)
{ coord.SetZ (Z); }

inline void gp_Pnt::SetXYZ (const gp_XYZ& Coordinates)
{ coord = Coordinates; }

inline Standard_Real gp_Pnt::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Pnt::Coord (Standard_Real& Xp,
Standard_Real& Yp,
Standard_Real& Zp) const {
coord.Coord (Xp, Yp, Zp);
}

inline Standard_Real gp_Pnt::X() const
{ return coord.X(); }

inline Standard_Real gp_Pnt::Y() const
{ return coord.Y(); }

inline Standard_Real gp_Pnt::Z() const
{ return coord.Z(); }

inline const gp_XYZ& gp_Pnt::XYZ () const
{ return coord; }

inline const gp_XYZ& gp_Pnt::Coord () const
{ return coord; }

inline gp_XYZ& gp_Pnt::ChangeCoord ()
{ return coord; }

inline void gp_Pnt::BaryCenter(const Standard_Real A,
const gp_Pnt& P,
const Standard_Real B)
{
coord.SetLinearForm(A,coord,B,P.coord);
coord.Divide(A + B);
}

inline Standard_Boolean gp_Pnt::IsEqual
(const gp_Pnt& Other,
const Standard_Real LinearTolerance) const
{ return Distance (Other) <= LinearTolerance; }

inline Standard_Real gp_Pnt::Distance (const gp_Pnt& Other) const
{
Standard_Real d=0,dd;
const gp_XYZ& XYZ = Other.coord;
dd = coord.X(); dd -= XYZ.X(); dd *= dd; d += dd;
dd = coord.Y(); dd -= XYZ.Y(); dd *= dd; d += dd;
dd = coord.Z(); dd -= XYZ.Z(); dd *= dd; d += dd;
return(sqrt(d));
}

inline Standard_Real gp_Pnt::SquareDistance (const gp_Pnt& Other) const
{
Standard_Real d=0,dd;
const gp_XYZ& XYZ = Other.coord;
dd = coord.X(); dd -= XYZ.X(); dd *= dd; d += dd;
dd = coord.Y(); dd -= XYZ.Y(); dd *= dd; d += dd;
dd = coord.Z(); dd -= XYZ.Z(); dd *= dd; d += dd;
return(d);
}

inline void gp_Pnt::Rotate (const gp_Ax1& A1,
const Standard_Real Ang)
{
gp_Trsf T;
T.SetRotation (A1, Ang);
T.Transforms (coord);
}

inline gp_Pnt gp_Pnt::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Pnt P = *this;
P.Rotate (A1, Ang);
return P;
}

inline void gp_Pnt::Scale (const gp_Pnt& P,
const Standard_Real S)
{
gp_XYZ XYZ = P.coord;
XYZ.Multiply (1.0 – S);
coord.Multiply (S);
coord.Add (XYZ);
}

inline gp_Pnt gp_Pnt::Scaled (const gp_Pnt& P,
const Standard_Real S) const
{
gp_Pnt Pres = *this;
Pres.Scale (P, S);
return Pres;
}

inline gp_Pnt gp_Pnt::Transformed (const gp_Trsf& T) const
{
gp_Pnt P = *this;
P.Transform (T);
return P;
}

inline void gp_Pnt::Translate (const gp_Vec& V)
{ coord.Add (V.XYZ()); }

inline gp_Pnt gp_Pnt::Translated (const gp_Vec& V) const
{
gp_Pnt P = *this;
P.coord.Add (V.XYZ());
return P;
}

inline void gp_Pnt::Translate (const gp_Pnt& P1,
const gp_Pnt& P2)
{
coord.Add (P2.coord);
coord.Subtract (P1.coord);
}

inline gp_Pnt gp_Pnt::Translated (const gp_Pnt& P1,
const gp_Pnt& P2) const
{
gp_Pnt P = *this;
P.Translate (P1 , P2);
return P;
}
# 223 “/usr/include/opencascade/gp_Pnt.hxx” 2
# 8 “/usr/include/opencascade/gp_Vec.lxx” 2

# 1 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx” 1
# 29 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx”
# 1 “/usr/include/opencascade/Handle_gp_VectorWithNullMagnitude.hxx” 1
# 36 “/usr/include/opencascade/Handle_gp_VectorWithNullMagnitude.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class gp_VectorWithNullMagnitude;
Handle_Standard_Type& gp_VectorWithNullMagnitude_Type_();

class Handle_gp_VectorWithNullMagnitude : public Handle_Standard_DomainError {
public:
Handle_gp_VectorWithNullMagnitude():Handle_Standard_DomainError() {}
Handle_gp_VectorWithNullMagnitude(const Handle_gp_VectorWithNullMagnitude& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_gp_VectorWithNullMagnitude(const gp_VectorWithNullMagnitude* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_gp_VectorWithNullMagnitude& operator=(const Handle_gp_VectorWithNullMagnitude& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_gp_VectorWithNullMagnitude& operator=(const gp_VectorWithNullMagnitude* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

gp_VectorWithNullMagnitude* operator->() const
{
return (gp_VectorWithNullMagnitude *)ControlAccess();
}

static const Handle_gp_VectorWithNullMagnitude DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx” 2
# 49 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx”
class gp_VectorWithNullMagnitude : public Standard_DomainError {

virtual void Throw() const;

public:
gp_VectorWithNullMagnitude():Standard_DomainError(){}
gp_VectorWithNullMagnitude(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_gp_VectorWithNullMagnitude NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& gp_VectorWithNullMagnitude_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 10 “/usr/include/opencascade/gp_Vec.lxx” 2

inline gp_Vec::gp_Vec() { }

inline gp_Vec::gp_Vec (const gp_Dir& V) { coord = V.XYZ(); }

inline gp_Vec::gp_Vec (const gp_XYZ& Coord) : coord(Coord) { }

inline gp_Vec::gp_Vec (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv)
: coord (Xv, Yv, Zv) { }

inline gp_Vec::gp_Vec (const gp_Pnt& P1,
const gp_Pnt& P2)
{ coord = P2.XYZ().Subtracted(P1.XYZ()); }

inline void gp_Vec::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Vec::SetCoord (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv)
{
coord.SetX(Xv);
coord.SetY(Yv);
coord.SetZ(Zv);
}

inline void gp_Vec::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Vec::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Vec::SetZ (const Standard_Real Z)
{ coord.SetZ (Z); }

inline void gp_Vec::SetXYZ (const gp_XYZ& Coord)
{ coord = Coord; }

inline Standard_Real gp_Vec::Coord (const Standard_Integer Index) const
{ return coord.Coord (Index); }

inline void gp_Vec::Coord(Standard_Real& Xv,
Standard_Real& Yv,
Standard_Real& Zv) const
{
Xv = coord.X();
Yv = coord.Y();
Zv = coord.Z();
}

inline Standard_Real gp_Vec::X() const
{ return coord.X(); }

inline Standard_Real gp_Vec::Y() const
{ return coord.Y(); }

inline Standard_Real gp_Vec::Z() const
{ return coord.Z(); }

inline const gp_XYZ& gp_Vec::XYZ () const
{ return coord; }

inline Standard_Boolean gp_Vec::IsNormal
(const gp_Vec& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Standard_PI / 2.0 – Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec::IsOpposite
(const gp_Vec& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Standard_PI – Angle(Other);
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec::IsParallel
(const gp_Vec& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle (Other);
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Real gp_Vec::Angle (const gp_Vec& Other) const
{
# 111 “/usr/include/opencascade/gp_Vec.lxx”
if (coord.Modulus() <= gp::Resolution() || Other.coord.Modulus() <= gp::Resolution()) gp_VectorWithNullMagnitude::Raise(” “);;

return (gp_Dir(coord)).Angle(Other);
}

inline Standard_Real gp_Vec::AngleWithRef (const gp_Vec& Other,
const gp_Vec& Vref) const
{
if (coord.Modulus() <= gp::Resolution() || Vref.coord.Modulus () <= gp::Resolution() || Other.coord.Modulus() <= gp::Resolution()) gp_VectorWithNullMagnitude::Raise(” “);;

return (gp_Dir(coord)).AngleWithRef(Other,Vref);
}

inline Standard_Real gp_Vec::Magnitude() const
{ return coord.Modulus(); }

inline Standard_Real gp_Vec::SquareMagnitude() const
{ return coord.SquareModulus(); }

inline void gp_Vec::Add (const gp_Vec& Other)
{ coord.Add (Other.coord); }

inline gp_Vec gp_Vec::Added (const gp_Vec& Other) const
{
gp_Vec V = *this;
V.coord.Add (Other.coord);
return V;
}

inline void gp_Vec::Subtract (const gp_Vec& Right)
{ coord.Subtract (Right.coord); }

inline gp_Vec gp_Vec::Subtracted (const gp_Vec& Right) const
{
gp_Vec V = *this;
V.coord.Subtract(Right.coord);
return V;
}

inline void gp_Vec::Multiply (const Standard_Real Scalar)
{ coord.Multiply(Scalar); }

inline gp_Vec gp_Vec::Multiplied (const Standard_Real Scalar) const
{
gp_Vec V = *this;
V.coord.Multiply (Scalar);
return V;
}

inline void gp_Vec::Divide (const Standard_Real Scalar)
{ coord.Divide (Scalar); }

inline gp_Vec gp_Vec::Divided (const Standard_Real Scalar) const
{
gp_Vec V = *this;
V.coord.Divide (Scalar);
return V;
}

inline void gp_Vec::Cross (const gp_Vec& Right)
{ coord.Cross (Right.coord); }

inline gp_Vec gp_Vec::Crossed (const gp_Vec& Right) const
{
gp_Vec V = *this;
V.coord.Cross (Right.coord);
return V;
}

inline Standard_Real gp_Vec::CrossMagnitude
(const gp_Vec& Right) const
{ return coord.CrossMagnitude (Right.coord); }

inline Standard_Real gp_Vec::CrossSquareMagnitude
(const gp_Vec& Right) const
{ return coord.CrossSquareMagnitude (Right.coord); }

inline void gp_Vec::CrossCross (const gp_Vec& V1,
const gp_Vec& V2)
{ coord.CrossCross(V1.coord, V2.coord); }

inline gp_Vec gp_Vec::CrossCrossed (const gp_Vec& V1,
const gp_Vec& V2) const
{
gp_Vec V = *this;
V.coord.CrossCross(V1.coord, V2.coord);
return V;
}

inline Standard_Real gp_Vec::Dot (const gp_Vec& Other) const
{ return coord.Dot (Other.coord); }

inline Standard_Real gp_Vec::DotCross (const gp_Vec& V1,
const gp_Vec& V2) const
{ return coord.DotCross (V1.coord, V2.coord); }

inline void gp_Vec::Normalize()
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide (D);
}

inline gp_Vec gp_Vec::Normalized() const
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
gp_Vec V = *this;
V.coord.Divide (D);
return V;
}

inline void gp_Vec::Reverse()
{ coord.Reverse(); }

inline gp_Vec gp_Vec::Reversed () const
{
gp_Vec V = *this;
V.coord.Reverse();
return V;
}

inline void gp_Vec::SetLinearForm
(const Standard_Real L,
const gp_Vec& Left,
const Standard_Real R,
const gp_Vec& Right)
{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real L,
const gp_Vec& Left,
const gp_Vec& Right)
{ coord.SetLinearForm (L, Left.coord, Right.coord); }

inline void gp_Vec::SetLinearForm
(const gp_Vec& Left,
const gp_Vec& Right)
{ coord.SetLinearForm (Left.coord, Right.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1,
const Standard_Real A2, const gp_Vec& V2,
const Standard_Real A3, const gp_Vec& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, A3, V3.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1,
const Standard_Real A2, const gp_Vec& V2,
const gp_Vec& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1,
const Standard_Real A2, const gp_Vec& V2,
const Standard_Real A3, const gp_Vec& V3,
const gp_Vec& V4)
{ coord.SetLinearForm(A1,V1.coord,A2,V2.coord,A3,V3.coord,V4.coord); }

inline void gp_Vec::Rotate (const gp_Ax1& A1,
const Standard_Real Ang)
{
gp_Trsf T;
T.SetRotation (A1, Ang);
coord.Multiply (T.VectorialPart());
}

inline gp_Vec gp_Vec::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Vec Vres = *this;
Vres.Rotate (A1, Ang);
return Vres;
}

inline void gp_Vec::Scale (const Standard_Real S)
{ coord.Multiply (S); }

inline gp_Vec gp_Vec::Scaled (const Standard_Real S) const
{
gp_Vec V = *this;
V.coord.Multiply(S);
return V;
}

inline gp_Vec gp_Vec::Transformed (const gp_Trsf& T) const
{
gp_Vec V = *this;
V.Transform(T);
return V;
}

inline gp_Vec operator* (const Standard_Real Scalar, const gp_Vec& V) {
return V.Multiplied(Scalar);
}
# 389 “/usr/include/opencascade/gp_Vec.hxx” 2
# 9 “/usr/include/opencascade/gp_Trsf.lxx” 2

inline gp_Trsf::gp_Trsf () :
scale(1.0),
shape(gp_Identity),
matrix(1,0,0, 0,1,0, 0,0,1),
loc(0.0, 0.0, 0.0)
{}

inline gp_Trsf::gp_Trsf (const gp_Trsf2d& T) :
scale(T.ScaleFactor()),
shape(T.Form()),
loc(T.TranslationPart().X(),T.TranslationPart().Y(), 0.0)
{
const gp_Mat2d& M = T.HVectorialPart();
matrix(1,1) = M(1,1);
matrix(1,2) = M(1,2);
matrix(2,1) = M(2,1);
matrix(2,2) = M(2,2);
matrix(3,3) = 1.;
}

inline void gp_Trsf::SetMirror (const gp_Pnt& P)
{
shape = gp_PntMirror;
scale = -1.0;
loc = P.XYZ();
matrix.SetIdentity ();
loc.Multiply(2.0);
}

inline void gp_Trsf::SetTranslation (const gp_Vec& V)
{
shape = gp_Translation;
scale = 1.;
matrix.SetIdentity ();
loc = V.XYZ();
}

inline void gp_Trsf::SetTranslation(const gp_Pnt& P1,
const gp_Pnt& P2)
{
shape = gp_Translation;
scale = 1.0;
matrix.SetIdentity ();
loc = (P2.XYZ()).Subtracted (P1.XYZ());
}

inline Standard_Boolean gp_Trsf::IsNegative() const
{ return (scale < 0.0); }

inline const gp_XYZ& gp_Trsf::TranslationPart () const
{ return loc; }

inline const gp_Mat& gp_Trsf::HVectorialPart () const
{ return matrix; }

inline Standard_Real gp_Trsf::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 4) Standard_OutOfRange::Raise(” “);;

if (Col < 4) return scale * matrix.Value (Row, Col);
else return loc.Coord (Row);
}

inline gp_TrsfForm gp_Trsf::Form () const
{ return shape; }

inline Standard_Real gp_Trsf::ScaleFactor () const
{ return scale; }

inline gp_Trsf gp_Trsf::Inverted() const
{
gp_Trsf T = *this;
T.Invert();
return T;
}

inline gp_Trsf gp_Trsf::Multiplied (const gp_Trsf& T) const
{
gp_Trsf Tresult(*this);
Tresult.Multiply(T);
return Tresult;
}

inline gp_Trsf gp_Trsf::Powered (const Standard_Integer N)
{
gp_Trsf T = *this;
T.Power (N);
return T;
}

inline void gp_Trsf::Transforms (Standard_Real& X,
Standard_Real& Y,
Standard_Real& Z) const
{
gp_XYZ Triplet (X, Y, Z);
Triplet.Multiply (matrix);
if (scale != 1.0) Triplet.Multiply (scale);
Triplet.Add(loc);
X = Triplet.X();
Y = Triplet.Y();
Z = Triplet.Z();
}

inline void gp_Trsf::Transforms (gp_XYZ& Coord) const
{
Coord.Multiply (matrix);
if (scale != 1.0) Coord.Multiply (scale);
Coord.Add(loc);
}
# 377 “/usr/include/opencascade/gp_Trsf.hxx” 2
# 27 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx” 2
# 35 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx”
# 1 “/usr/include/opencascade/BRepTools_Modifier.hxx” 1
# 26 “/usr/include/opencascade/BRepTools_Modifier.hxx”
# 1 “/usr/include/opencascade/TopTools_DataMapOfShapeShape.hxx” 1
# 29 “/usr/include/opencascade/TopTools_DataMapOfShapeShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_DataMapNodeOfDataMapOfShapeShape;
Handle_Standard_Type& TopTools_DataMapNodeOfDataMapOfShapeShape_Type_();

class Handle_TopTools_DataMapNodeOfDataMapOfShapeShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_DataMapNodeOfDataMapOfShapeShape():Handle_TCollection_MapNode() {}
Handle_TopTools_DataMapNodeOfDataMapOfShapeShape(const Handle_TopTools_DataMapNodeOfDataMapOfShapeShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeShape(const TopTools_DataMapNodeOfDataMapOfShapeShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeShape& operator=(const Handle_TopTools_DataMapNodeOfDataMapOfShapeShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeShape& operator=(const TopTools_DataMapNodeOfDataMapOfShapeShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_DataMapNodeOfDataMapOfShapeShape* operator->() const
{
return (TopTools_DataMapNodeOfDataMapOfShapeShape *)ControlAccess();
}

static const Handle_TopTools_DataMapNodeOfDataMapOfShapeShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_DataMapOfShapeShape.hxx” 2

class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopTools_ShapeMapHasher;
class TopTools_DataMapNodeOfDataMapOfShapeShape;
class TopTools_DataMapIteratorOfDataMapOfShapeShape;
# 53 “/usr/include/opencascade/TopTools_DataMapOfShapeShape.hxx”
class TopTools_DataMapOfShapeShape : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_DataMapOfShapeShape(const Standard_Integer NbBuckets = 1);

TopTools_DataMapOfShapeShape& Assign(const TopTools_DataMapOfShapeShape& Other) ;
TopTools_DataMapOfShapeShape& operator =(const TopTools_DataMapOfShapeShape& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_DataMapOfShapeShape()
{
Clear();
}

Standard_Boolean Bind(const TopoDS_Shape& K,const TopoDS_Shape& I) ;

Standard_Boolean IsBound(const TopoDS_Shape& K) const;

Standard_Boolean UnBind(const TopoDS_Shape& K) ;

const TopoDS_Shape& Find(const TopoDS_Shape& K) const;
const TopoDS_Shape& operator()(const TopoDS_Shape& K) const
{
return Find(K);
}

TopoDS_Shape& ChangeFind(const TopoDS_Shape& K) ;
TopoDS_Shape& operator()(const TopoDS_Shape& K)
{
return ChangeFind(K);
}

protected:
# 133 “/usr/include/opencascade/TopTools_DataMapOfShapeShape.hxx”
private:

TopTools_DataMapOfShapeShape(const TopTools_DataMapOfShapeShape& Other);

};
# 27 “/usr/include/opencascade/BRepTools_Modifier.hxx” 2
# 35 “/usr/include/opencascade/BRepTools_Modifier.hxx”
# 1 “/usr/include/opencascade/Handle_BRepTools_Modification.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepTools_Modification.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class BRepTools_Modification;
Handle_Standard_Type& BRepTools_Modification_Type_();

class Handle_BRepTools_Modification : public Handle_MMgt_TShared {
public:
Handle_BRepTools_Modification():Handle_MMgt_TShared() {}
Handle_BRepTools_Modification(const Handle_BRepTools_Modification& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_BRepTools_Modification(const BRepTools_Modification* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_BRepTools_Modification& operator=(const Handle_BRepTools_Modification& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepTools_Modification& operator=(const BRepTools_Modification* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepTools_Modification* operator->() const
{
return (BRepTools_Modification *)ControlAccess();
}

static const Handle_BRepTools_Modification DownCast(const Handle_Standard_Transient& AnObject);
};
# 36 “/usr/include/opencascade/BRepTools_Modifier.hxx” 2

class Standard_NullObject;
class Standard_NoSuchObject;
class TopoDS_Shape;
class BRepTools_Modification;
# 54 “/usr/include/opencascade/BRepTools_Modifier.hxx”
class BRepTools_Modifier {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepTools_Modifier();

BRepTools_Modifier(const TopoDS_Shape& S);

BRepTools_Modifier(const TopoDS_Shape& S,const Handle_BRepTools_Modification& M);

void Init(const TopoDS_Shape& S) ;

void Perform(const Handle_BRepTools_Modification& M) ;

Standard_Boolean IsDone() const;

const TopoDS_Shape& ModifiedShape(const TopoDS_Shape& S) const;

protected:
# 109 “/usr/include/opencascade/BRepTools_Modifier.hxx”
private:

void Put(const TopoDS_Shape& S) ;

Standard_Boolean Rebuild(const TopoDS_Shape& S,const Handle_BRepTools_Modification& M,const Standard_Real Tolerance) ;

TopTools_DataMapOfShapeShape myMap;
TopoDS_Shape myShape;
Standard_Boolean myDone;

};

# 1 “/usr/include/opencascade/BRepTools_Modifier.lxx” 1

# 1 “/usr/include/opencascade/Standard_NoSuchObject.hxx” 1
# 29 “/usr/include/opencascade/Standard_NoSuchObject.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_NoSuchObject.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_NoSuchObject.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class Standard_NoSuchObject;
Handle_Standard_Type& Standard_NoSuchObject_Type_();

class Handle_Standard_NoSuchObject : public Handle_Standard_DomainError {
public:
Handle_Standard_NoSuchObject():Handle_Standard_DomainError() {}
Handle_Standard_NoSuchObject(const Handle_Standard_NoSuchObject& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_Standard_NoSuchObject(const Standard_NoSuchObject* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_Standard_NoSuchObject& operator=(const Handle_Standard_NoSuchObject& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_NoSuchObject& operator=(const Standard_NoSuchObject* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_NoSuchObject* operator->() const
{
return (Standard_NoSuchObject *)ControlAccess();
}

static const Handle_Standard_NoSuchObject DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/Standard_NoSuchObject.hxx” 2
# 49 “/usr/include/opencascade/Standard_NoSuchObject.hxx”
class Standard_NoSuchObject : public Standard_DomainError {

virtual void Throw() const;

public:
Standard_NoSuchObject():Standard_DomainError(){}
Standard_NoSuchObject(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_NoSuchObject NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_NoSuchObject_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 8 “/usr/include/opencascade/BRepTools_Modifier.lxx” 2

inline const TopoDS_Shape& BRepTools_Modifier::ModifiedShape
(const TopoDS_Shape& S) const
{
if (!myMap.IsBound(S)) { Standard_NoSuchObject::Raise();}
return myMap(S);
}

inline Standard_Boolean BRepTools_Modifier::IsDone () const
{
return myDone;
}
# 132 “/usr/include/opencascade/BRepTools_Modifier.hxx” 2
# 27 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx” 2
# 37 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx”
class BRepTools_Modification;
class Standard_NullObject;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopTools_ListOfShape;
# 66 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx”
class BRepBuilderAPI_ModifyShape : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;
# 97 “/usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx”
virtual const TopoDS_Shape& ModifiedShape(const TopoDS_Shape& S) const;

protected:

BRepBuilderAPI_ModifyShape();

BRepBuilderAPI_ModifyShape(const TopoDS_Shape& S);

BRepBuilderAPI_ModifyShape(const Handle_BRepTools_Modification& M);

BRepBuilderAPI_ModifyShape(const TopoDS_Shape& S,const Handle_BRepTools_Modification& M);

void DoModif(const TopoDS_Shape& S) ;

void DoModif(const Handle_BRepTools_Modification& M) ;

void DoModif(const TopoDS_Shape& S,const Handle_BRepTools_Modification& M) ;

BRepTools_Modifier myModifier;
TopoDS_Shape myInitialShape;
Handle_BRepTools_Modification myModification;

private:

void DoModif() ;

};
# 36 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx” 2

class Standard_NoSuchObject;
class gp_Trsf;
class TopoDS_Shape;
class TopTools_ListOfShape;
# 61 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
class BRepBuilderAPI_Transform : public BRepBuilderAPI_ModifyShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepBuilderAPI_Transform(const gp_Trsf& T);
# 92 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
BRepBuilderAPI_Transform(const TopoDS_Shape& S,const gp_Trsf& T,const Standard_Boolean Copy = (Standard_Boolean) 0);
# 106 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
void Perform(const TopoDS_Shape& S,const Standard_Boolean Copy = (Standard_Boolean) 0) ;

virtual const TopoDS_Shape& ModifiedShape(const TopoDS_Shape& S) const;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;

protected:
# 129 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
private:

gp_Trsf myTrsf;
TopLoc_Location myLocation;
Standard_Boolean myUseModif;

};
# 9 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx” 1
# 26 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
# 1 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 1
# 26 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx”
# 1 “/usr/include/opencascade/BlendFunc_SectionShape.hxx” 1
# 26 “/usr/include/opencascade/BlendFunc_SectionShape.hxx”
enum BlendFunc_SectionShape {
BlendFunc_Rational,
BlendFunc_QuasiAngular,
BlendFunc_Polynomial,
BlendFunc_Linear
};
# 27 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 2

# 1 “/usr/include/opencascade/ChFi3d_Builder.hxx” 1
# 35 “/usr/include/opencascade/ChFi3d_Builder.hxx”
# 1 “/usr/include/opencascade/ChFiDS_Map.hxx” 1
# 26 “/usr/include/opencascade/ChFiDS_Map.hxx”
# 1 “/usr/include/opencascade/TopTools_IndexedDataMapOfShapeListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopTools_IndexedDataMapOfShapeListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape;
Handle_Standard_Type& TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape_Type_();

class Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape(const Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape(const TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape& operator=(const Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape& operator=(const TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape* operator->() const
{
return (TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape *)ControlAccess();
}

static const Handle_TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_IndexedDataMapOfShapeListOfShape.hxx” 2

class Standard_DomainError;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopTools_ListOfShape;
class TopTools_ShapeMapHasher;
class TopTools_IndexedDataMapNodeOfIndexedDataMapOfShapeListOfShape;
# 54 “/usr/include/opencascade/TopTools_IndexedDataMapOfShapeListOfShape.hxx”
class TopTools_IndexedDataMapOfShapeListOfShape : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_IndexedDataMapOfShapeListOfShape(const Standard_Integer NbBuckets = 1);

TopTools_IndexedDataMapOfShapeListOfShape& Assign(const TopTools_IndexedDataMapOfShapeListOfShape& Other) ;
TopTools_IndexedDataMapOfShapeListOfShape& operator =(const TopTools_IndexedDataMapOfShapeListOfShape& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_IndexedDataMapOfShapeListOfShape()
{
Clear();
}

Standard_Integer Add(const TopoDS_Shape& K,const TopTools_ListOfShape& I) ;

void Substitute(const Standard_Integer I,const TopoDS_Shape& K,const TopTools_ListOfShape& T) ;

void RemoveLast() ;

Standard_Boolean Contains(const TopoDS_Shape& K) const;

const TopoDS_Shape& FindKey(const Standard_Integer I) const;

const TopTools_ListOfShape& FindFromIndex(const Standard_Integer I) const;
const TopTools_ListOfShape& operator ()(const Standard_Integer I) const
{
return FindFromIndex(I);
}

TopTools_ListOfShape& ChangeFromIndex(const Standard_Integer I) ;
TopTools_ListOfShape& operator ()(const Standard_Integer I)
{
return ChangeFromIndex(I);
}

Standard_Integer FindIndex(const TopoDS_Shape& K) const;

const TopTools_ListOfShape& FindFromKey(const TopoDS_Shape& K) const;

TopTools_ListOfShape& ChangeFromKey(const TopoDS_Shape& K) ;

protected:
# 149 “/usr/include/opencascade/TopTools_IndexedDataMapOfShapeListOfShape.hxx”
private:

TopTools_IndexedDataMapOfShapeListOfShape(const TopTools_IndexedDataMapOfShapeListOfShape& Other);

};
# 27 “/usr/include/opencascade/ChFiDS_Map.hxx” 2
# 37 “/usr/include/opencascade/ChFiDS_Map.hxx”
class TopoDS_Shape;
class TopTools_ListOfShape;
# 49 “/usr/include/opencascade/ChFiDS_Map.hxx”
class ChFiDS_Map {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFiDS_Map();

void Fill(const TopoDS_Shape& S,const TopAbs_ShapeEnum T1,const TopAbs_ShapeEnum T2) ;

Standard_Boolean Contains(const TopoDS_Shape& S) const;

const TopTools_ListOfShape& FindFromKey(const TopoDS_Shape& S) const;
const TopTools_ListOfShape& operator()(const TopoDS_Shape& S) const
{
return FindFromKey(S);
}

const TopTools_ListOfShape& FindFromIndex(const Standard_Integer I) const;
const TopTools_ListOfShape& operator()(const Standard_Integer I) const
{
return FindFromIndex(I);
}

protected:
# 108 “/usr/include/opencascade/ChFiDS_Map.hxx”
private:

TopTools_IndexedDataMapOfShapeListOfShape myMap;

};
# 36 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopOpeBRepDS_HDataStructure.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopOpeBRepDS_HDataStructure.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopOpeBRepDS_HDataStructure;
Handle_Standard_Type& TopOpeBRepDS_HDataStructure_Type_();

class Handle_TopOpeBRepDS_HDataStructure : public Handle_MMgt_TShared {
public:
Handle_TopOpeBRepDS_HDataStructure():Handle_MMgt_TShared() {}
Handle_TopOpeBRepDS_HDataStructure(const Handle_TopOpeBRepDS_HDataStructure& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopOpeBRepDS_HDataStructure(const TopOpeBRepDS_HDataStructure* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopOpeBRepDS_HDataStructure& operator=(const Handle_TopOpeBRepDS_HDataStructure& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopOpeBRepDS_HDataStructure& operator=(const TopOpeBRepDS_HDataStructure* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopOpeBRepDS_HDataStructure* operator->() const
{
return (TopOpeBRepDS_HDataStructure *)ControlAccess();
}

static const Handle_TopOpeBRepDS_HDataStructure DownCast(const Handle_Standard_Transient& AnObject);
};
# 39 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopOpeBRepBuild_HBuilder.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopOpeBRepBuild_HBuilder.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopOpeBRepBuild_HBuilder;
Handle_Standard_Type& TopOpeBRepBuild_HBuilder_Type_();

class Handle_TopOpeBRepBuild_HBuilder : public Handle_MMgt_TShared {
public:
Handle_TopOpeBRepBuild_HBuilder():Handle_MMgt_TShared() {}
Handle_TopOpeBRepBuild_HBuilder(const Handle_TopOpeBRepBuild_HBuilder& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopOpeBRepBuild_HBuilder(const TopOpeBRepBuild_HBuilder* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopOpeBRepBuild_HBuilder& operator=(const Handle_TopOpeBRepBuild_HBuilder& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopOpeBRepBuild_HBuilder& operator=(const TopOpeBRepBuild_HBuilder* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopOpeBRepBuild_HBuilder* operator->() const
{
return (TopOpeBRepBuild_HBuilder *)ControlAccess();
}

static const Handle_TopOpeBRepBuild_HBuilder DownCast(const Handle_Standard_Transient& AnObject);
};
# 42 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx” 1
# 29 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx”
# 1 “/usr/include/opencascade/Handle_ChFiDS_Stripe.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_Stripe.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class ChFiDS_Stripe;
Handle_Standard_Type& ChFiDS_Stripe_Type_();

class Handle_ChFiDS_Stripe : public Handle_MMgt_TShared {
public:
Handle_ChFiDS_Stripe():Handle_MMgt_TShared() {}
Handle_ChFiDS_Stripe(const Handle_ChFiDS_Stripe& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_ChFiDS_Stripe(const ChFiDS_Stripe* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_ChFiDS_Stripe& operator=(const Handle_ChFiDS_Stripe& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_Stripe& operator=(const ChFiDS_Stripe* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_Stripe* operator->() const
{
return (ChFiDS_Stripe *)ControlAccess();
}

static const Handle_ChFiDS_Stripe DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx” 2

# 1 “/usr/include/opencascade/Handle_ChFiDS_ListNodeOfListOfStripe.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_ListNodeOfListOfStripe.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class ChFiDS_ListNodeOfListOfStripe;
Handle_Standard_Type& ChFiDS_ListNodeOfListOfStripe_Type_();

class Handle_ChFiDS_ListNodeOfListOfStripe : public Handle_TCollection_MapNode {
public:
Handle_ChFiDS_ListNodeOfListOfStripe():Handle_TCollection_MapNode() {}
Handle_ChFiDS_ListNodeOfListOfStripe(const Handle_ChFiDS_ListNodeOfListOfStripe& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_ChFiDS_ListNodeOfListOfStripe(const ChFiDS_ListNodeOfListOfStripe* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_ChFiDS_ListNodeOfListOfStripe& operator=(const Handle_ChFiDS_ListNodeOfListOfStripe& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_ListNodeOfListOfStripe& operator=(const ChFiDS_ListNodeOfListOfStripe* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_ListNodeOfListOfStripe* operator->() const
{
return (ChFiDS_ListNodeOfListOfStripe *)ControlAccess();
}

static const Handle_ChFiDS_ListNodeOfListOfStripe DownCast(const Handle_Standard_Transient& AnObject);
};
# 33 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx” 2

class Standard_NoSuchObject;
class ChFiDS_ListIteratorOfListOfStripe;
class ChFiDS_Stripe;
class ChFiDS_ListNodeOfListOfStripe;
# 54 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx”
class ChFiDS_ListOfStripe {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFiDS_ListOfStripe();

void Assign(const ChFiDS_ListOfStripe& Other) ;
void operator=(const ChFiDS_ListOfStripe& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~ChFiDS_ListOfStripe()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const Handle_ChFiDS_Stripe& I) ;

void Prepend(const Handle_ChFiDS_Stripe& I,ChFiDS_ListIteratorOfListOfStripe& theIt) ;

void Prepend(ChFiDS_ListOfStripe& Other) ;

void Append(const Handle_ChFiDS_Stripe& I) ;

void Append(const Handle_ChFiDS_Stripe& I,ChFiDS_ListIteratorOfListOfStripe& theIt) ;

void Append(ChFiDS_ListOfStripe& Other) ;

Handle_ChFiDS_Stripe& First() const;

Handle_ChFiDS_Stripe& Last() const;

void RemoveFirst() ;

void Remove(ChFiDS_ListIteratorOfListOfStripe& It) ;

void InsertBefore(const Handle_ChFiDS_Stripe& I,ChFiDS_ListIteratorOfListOfStripe& It) ;

void InsertBefore(ChFiDS_ListOfStripe& Other,ChFiDS_ListIteratorOfListOfStripe& It) ;

void InsertAfter(const Handle_ChFiDS_Stripe& I,ChFiDS_ListIteratorOfListOfStripe& It) ;

void InsertAfter(ChFiDS_ListOfStripe& Other,ChFiDS_ListIteratorOfListOfStripe& It) ;

friend class ChFiDS_ListIteratorOfListOfStripe;

protected:
# 154 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx”
private:

ChFiDS_ListOfStripe(const ChFiDS_ListOfStripe& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 182 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean ChFiDS_ListOfStripe::IsEmpty() const

{
return myFirst == 0L;
}
# 183 “/usr/include/opencascade/ChFiDS_ListOfStripe.hxx” 2
# 45 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/ChFiDS_StripeMap.hxx” 1
# 26 “/usr/include/opencascade/ChFiDS_StripeMap.hxx”
# 1 “/usr/include/opencascade/ChFiDS_IndexedDataMapOfVertexListOfStripe.hxx” 1
# 29 “/usr/include/opencascade/ChFiDS_IndexedDataMapOfVertexListOfStripe.hxx”
# 1 “/usr/include/opencascade/Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe;
Handle_Standard_Type& ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Type_();

class Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe : public Handle_TCollection_MapNode {
public:
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe():Handle_TCollection_MapNode() {}
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(const Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(const ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe& operator=(const Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe& operator=(const ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe* operator->() const
{
return (ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe *)ControlAccess();
}

static const Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/ChFiDS_IndexedDataMapOfVertexListOfStripe.hxx” 2

class Standard_DomainError;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class TopoDS_Vertex;
class ChFiDS_ListOfStripe;
class TopTools_ShapeMapHasher;
class ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe;
# 54 “/usr/include/opencascade/ChFiDS_IndexedDataMapOfVertexListOfStripe.hxx”
class ChFiDS_IndexedDataMapOfVertexListOfStripe : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFiDS_IndexedDataMapOfVertexListOfStripe(const Standard_Integer NbBuckets = 1);

ChFiDS_IndexedDataMapOfVertexListOfStripe& Assign(const ChFiDS_IndexedDataMapOfVertexListOfStripe& Other) ;
ChFiDS_IndexedDataMapOfVertexListOfStripe& operator =(const ChFiDS_IndexedDataMapOfVertexListOfStripe& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~ChFiDS_IndexedDataMapOfVertexListOfStripe()
{
Clear();
}

Standard_Integer Add(const TopoDS_Vertex& K,const ChFiDS_ListOfStripe& I) ;

void Substitute(const Standard_Integer I,const TopoDS_Vertex& K,const ChFiDS_ListOfStripe& T) ;

void RemoveLast() ;

Standard_Boolean Contains(const TopoDS_Vertex& K) const;

const TopoDS_Vertex& FindKey(const Standard_Integer I) const;

const ChFiDS_ListOfStripe& FindFromIndex(const Standard_Integer I) const;
const ChFiDS_ListOfStripe& operator ()(const Standard_Integer I) const
{
return FindFromIndex(I);
}

ChFiDS_ListOfStripe& ChangeFromIndex(const Standard_Integer I) ;
ChFiDS_ListOfStripe& operator ()(const Standard_Integer I)
{
return ChangeFromIndex(I);
}

Standard_Integer FindIndex(const TopoDS_Vertex& K) const;

const ChFiDS_ListOfStripe& FindFromKey(const TopoDS_Vertex& K) const;

ChFiDS_ListOfStripe& ChangeFromKey(const TopoDS_Vertex& K) ;

protected:
# 149 “/usr/include/opencascade/ChFiDS_IndexedDataMapOfVertexListOfStripe.hxx”
private:

ChFiDS_IndexedDataMapOfVertexListOfStripe(const ChFiDS_IndexedDataMapOfVertexListOfStripe& Other);

};
# 27 “/usr/include/opencascade/ChFiDS_StripeMap.hxx” 2

class TopoDS_Vertex;
class ChFiDS_Stripe;
class ChFiDS_ListOfStripe;
# 47 “/usr/include/opencascade/ChFiDS_StripeMap.hxx”
class ChFiDS_StripeMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFiDS_StripeMap();

void Add(const TopoDS_Vertex& V,const Handle_ChFiDS_Stripe& F) ;

Standard_Integer Extent() const;

const ChFiDS_ListOfStripe& FindFromKey(const TopoDS_Vertex& V) const;
const ChFiDS_ListOfStripe& operator()(const TopoDS_Vertex& V) const
{
return FindFromKey(V);
}

const ChFiDS_ListOfStripe& FindFromIndex(const Standard_Integer I) const;
const ChFiDS_ListOfStripe& operator()(const Standard_Integer I) const
{
return FindFromIndex(I);
}

const TopoDS_Vertex& FindKey(const Standard_Integer I) const;

void Clear() ;

protected:
# 109 “/usr/include/opencascade/ChFiDS_StripeMap.hxx”
private:

ChFiDS_IndexedDataMapOfVertexListOfStripe mymap;

};

# 1 “/usr/include/opencascade/ChFiDS_StripeMap.lxx” 1
# 12 “/usr/include/opencascade/ChFiDS_StripeMap.lxx”
inline Standard_Integer ChFiDS_StripeMap::Extent() const {
return mymap.Extent();
}

inline const TopoDS_Vertex& ChFiDS_StripeMap::FindKey
(const Standard_Integer I) const {
return mymap.FindKey(I);
}
# 124 “/usr/include/opencascade/ChFiDS_StripeMap.hxx” 2
# 48 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/ChFiDS_Regularities.hxx” 1
# 29 “/usr/include/opencascade/ChFiDS_Regularities.hxx”
# 1 “/usr/include/opencascade/Handle_ChFiDS_ListNodeOfRegularities.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_ListNodeOfRegularities.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class ChFiDS_ListNodeOfRegularities;
Handle_Standard_Type& ChFiDS_ListNodeOfRegularities_Type_();

class Handle_ChFiDS_ListNodeOfRegularities : public Handle_TCollection_MapNode {
public:
Handle_ChFiDS_ListNodeOfRegularities():Handle_TCollection_MapNode() {}
Handle_ChFiDS_ListNodeOfRegularities(const Handle_ChFiDS_ListNodeOfRegularities& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_ChFiDS_ListNodeOfRegularities(const ChFiDS_ListNodeOfRegularities* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_ChFiDS_ListNodeOfRegularities& operator=(const Handle_ChFiDS_ListNodeOfRegularities& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_ListNodeOfRegularities& operator=(const ChFiDS_ListNodeOfRegularities* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_ListNodeOfRegularities* operator->() const
{
return (ChFiDS_ListNodeOfRegularities *)ControlAccess();
}

static const Handle_ChFiDS_ListNodeOfRegularities DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/ChFiDS_Regularities.hxx” 2

class Standard_NoSuchObject;
class ChFiDS_ListIteratorOfRegularities;
class ChFiDS_Regul;
class ChFiDS_ListNodeOfRegularities;
# 51 “/usr/include/opencascade/ChFiDS_Regularities.hxx”
class ChFiDS_Regularities {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFiDS_Regularities();

void Assign(const ChFiDS_Regularities& Other) ;
void operator=(const ChFiDS_Regularities& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~ChFiDS_Regularities()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const ChFiDS_Regul& I) ;

void Prepend(const ChFiDS_Regul& I,ChFiDS_ListIteratorOfRegularities& theIt) ;

void Prepend(ChFiDS_Regularities& Other) ;

void Append(const ChFiDS_Regul& I) ;

void Append(const ChFiDS_Regul& I,ChFiDS_ListIteratorOfRegularities& theIt) ;

void Append(ChFiDS_Regularities& Other) ;

ChFiDS_Regul& First() const;

ChFiDS_Regul& Last() const;

void RemoveFirst() ;

void Remove(ChFiDS_ListIteratorOfRegularities& It) ;

void InsertBefore(const ChFiDS_Regul& I,ChFiDS_ListIteratorOfRegularities& It) ;

void InsertBefore(ChFiDS_Regularities& Other,ChFiDS_ListIteratorOfRegularities& It) ;

void InsertAfter(const ChFiDS_Regul& I,ChFiDS_ListIteratorOfRegularities& It) ;

void InsertAfter(ChFiDS_Regularities& Other,ChFiDS_ListIteratorOfRegularities& It) ;

friend class ChFiDS_ListIteratorOfRegularities;

protected:
# 151 “/usr/include/opencascade/ChFiDS_Regularities.hxx”
private:

ChFiDS_Regularities(const ChFiDS_Regularities& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 179 “/usr/include/opencascade/ChFiDS_Regularities.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean ChFiDS_Regularities::IsEmpty() const

{
return myFirst == 0L;
}
# 180 “/usr/include/opencascade/ChFiDS_Regularities.hxx” 2
# 51 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfInteger.hxx” 1
# 29 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfInteger.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_DataMapNodeOfDataMapOfShapeListOfInteger;
Handle_Standard_Type& TopTools_DataMapNodeOfDataMapOfShapeListOfInteger_Type_();

class Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger : public Handle_TCollection_MapNode {
public:
Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger():Handle_TCollection_MapNode() {}
Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger(const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger(const TopTools_DataMapNodeOfDataMapOfShapeListOfInteger* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger& operator=(const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger& operator=(const TopTools_DataMapNodeOfDataMapOfShapeListOfInteger* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_DataMapNodeOfDataMapOfShapeListOfInteger* operator->() const
{
return (TopTools_DataMapNodeOfDataMapOfShapeListOfInteger *)ControlAccess();
}

static const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfInteger DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfInteger.hxx” 2

class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TColStd_ListOfInteger;
class TopTools_ShapeMapHasher;
class TopTools_DataMapNodeOfDataMapOfShapeListOfInteger;
class TopTools_DataMapIteratorOfDataMapOfShapeListOfInteger;
# 54 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfInteger.hxx”
class TopTools_DataMapOfShapeListOfInteger : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_DataMapOfShapeListOfInteger(const Standard_Integer NbBuckets = 1);

TopTools_DataMapOfShapeListOfInteger& Assign(const TopTools_DataMapOfShapeListOfInteger& Other) ;
TopTools_DataMapOfShapeListOfInteger& operator =(const TopTools_DataMapOfShapeListOfInteger& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_DataMapOfShapeListOfInteger()
{
Clear();
}

Standard_Boolean Bind(const TopoDS_Shape& K,const TColStd_ListOfInteger& I) ;

Standard_Boolean IsBound(const TopoDS_Shape& K) const;

Standard_Boolean UnBind(const TopoDS_Shape& K) ;

const TColStd_ListOfInteger& Find(const TopoDS_Shape& K) const;
const TColStd_ListOfInteger& operator()(const TopoDS_Shape& K) const
{
return Find(K);
}

TColStd_ListOfInteger& ChangeFind(const TopoDS_Shape& K) ;
TColStd_ListOfInteger& operator()(const TopoDS_Shape& K)
{
return ChangeFind(K);
}

protected:
# 134 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfInteger.hxx”
private:

TopTools_DataMapOfShapeListOfInteger(const TopTools_DataMapOfShapeListOfInteger& Other);

};
# 57 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2
# 65 “/usr/include/opencascade/ChFi3d_Builder.hxx”
# 1 “/usr/include/opencascade/Handle_ChFiDS_Spine.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_Spine.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class ChFiDS_Spine;
Handle_Standard_Type& ChFiDS_Spine_Type_();

class Handle_ChFiDS_Spine : public Handle_MMgt_TShared {
public:
Handle_ChFiDS_Spine():Handle_MMgt_TShared() {}
Handle_ChFiDS_Spine(const Handle_ChFiDS_Spine& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_ChFiDS_Spine(const ChFiDS_Spine* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_ChFiDS_Spine& operator=(const Handle_ChFiDS_Spine& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_Spine& operator=(const ChFiDS_Spine* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_Spine* operator->() const
{
return (ChFiDS_Spine *)ControlAccess();
}

static const Handle_ChFiDS_Spine DownCast(const Handle_Standard_Transient& AnObject);
};
# 66 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/ChFiDS_ErrorStatus.hxx” 1
# 26 “/usr/include/opencascade/ChFiDS_ErrorStatus.hxx”
enum ChFiDS_ErrorStatus {
ChFiDS_Ok,
ChFiDS_Error,
ChFiDS_WalkingFailure,
ChFiDS_StartsolFailure,
ChFiDS_TwistedSurface
};
# 72 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_ChFiDS_SurfData.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_SurfData.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class ChFiDS_SurfData;
Handle_Standard_Type& ChFiDS_SurfData_Type_();

class Handle_ChFiDS_SurfData : public Handle_MMgt_TShared {
public:
Handle_ChFiDS_SurfData():Handle_MMgt_TShared() {}
Handle_ChFiDS_SurfData(const Handle_ChFiDS_SurfData& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_ChFiDS_SurfData(const ChFiDS_SurfData* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_ChFiDS_SurfData& operator=(const Handle_ChFiDS_SurfData& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_SurfData& operator=(const ChFiDS_SurfData* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_SurfData* operator->() const
{
return (ChFiDS_SurfData *)ControlAccess();
}

static const Handle_ChFiDS_SurfData DownCast(const Handle_Standard_Transient& AnObject);
};
# 75 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_ChFiDS_HElSpine.hxx” 1
# 33 “/usr/include/opencascade/Handle_ChFiDS_HElSpine.hxx”
# 1 “/usr/include/opencascade/Handle_Adaptor3d_HCurve.hxx” 1
# 36 “/usr/include/opencascade/Handle_Adaptor3d_HCurve.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Adaptor3d_HCurve;
Handle_Standard_Type& Adaptor3d_HCurve_Type_();

class Handle_Adaptor3d_HCurve : public Handle_MMgt_TShared {
public:
Handle_Adaptor3d_HCurve():Handle_MMgt_TShared() {}
Handle_Adaptor3d_HCurve(const Handle_Adaptor3d_HCurve& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Adaptor3d_HCurve(const Adaptor3d_HCurve* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Adaptor3d_HCurve& operator=(const Handle_Adaptor3d_HCurve& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Adaptor3d_HCurve& operator=(const Adaptor3d_HCurve* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Adaptor3d_HCurve* operator->() const
{
return (Adaptor3d_HCurve *)ControlAccess();
}

static const Handle_Adaptor3d_HCurve DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_ChFiDS_HElSpine.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Adaptor3d_HCurve;
class ChFiDS_HElSpine;
Handle_Standard_Type& ChFiDS_HElSpine_Type_();

class Handle_ChFiDS_HElSpine : public Handle_Adaptor3d_HCurve {
public:
Handle_ChFiDS_HElSpine():Handle_Adaptor3d_HCurve() {}
Handle_ChFiDS_HElSpine(const Handle_ChFiDS_HElSpine& aHandle) : Handle_Adaptor3d_HCurve(aHandle)
{
}

Handle_ChFiDS_HElSpine(const ChFiDS_HElSpine* anItem) : Handle_Adaptor3d_HCurve((Adaptor3d_HCurve *)anItem)
{
}

Handle_ChFiDS_HElSpine& operator=(const Handle_ChFiDS_HElSpine& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_HElSpine& operator=(const ChFiDS_HElSpine* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_HElSpine* operator->() const
{
return (ChFiDS_HElSpine *)ControlAccess();
}

static const Handle_ChFiDS_HElSpine DownCast(const Handle_Standard_Transient& AnObject);
};
# 78 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_BRepAdaptor_HSurface.hxx” 1
# 33 “/usr/include/opencascade/Handle_BRepAdaptor_HSurface.hxx”
# 1 “/usr/include/opencascade/Handle_Adaptor3d_HSurface.hxx” 1
# 36 “/usr/include/opencascade/Handle_Adaptor3d_HSurface.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Adaptor3d_HSurface;
Handle_Standard_Type& Adaptor3d_HSurface_Type_();

class Handle_Adaptor3d_HSurface : public Handle_MMgt_TShared {
public:
Handle_Adaptor3d_HSurface():Handle_MMgt_TShared() {}
Handle_Adaptor3d_HSurface(const Handle_Adaptor3d_HSurface& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Adaptor3d_HSurface(const Adaptor3d_HSurface* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Adaptor3d_HSurface& operator=(const Handle_Adaptor3d_HSurface& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Adaptor3d_HSurface& operator=(const Adaptor3d_HSurface* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Adaptor3d_HSurface* operator->() const
{
return (Adaptor3d_HSurface *)ControlAccess();
}

static const Handle_Adaptor3d_HSurface DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_BRepAdaptor_HSurface.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Adaptor3d_HSurface;
class BRepAdaptor_HSurface;
Handle_Standard_Type& BRepAdaptor_HSurface_Type_();

class Handle_BRepAdaptor_HSurface : public Handle_Adaptor3d_HSurface {
public:
Handle_BRepAdaptor_HSurface():Handle_Adaptor3d_HSurface() {}
Handle_BRepAdaptor_HSurface(const Handle_BRepAdaptor_HSurface& aHandle) : Handle_Adaptor3d_HSurface(aHandle)
{
}

Handle_BRepAdaptor_HSurface(const BRepAdaptor_HSurface* anItem) : Handle_Adaptor3d_HSurface((Adaptor3d_HSurface *)anItem)
{
}

Handle_BRepAdaptor_HSurface& operator=(const Handle_BRepAdaptor_HSurface& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepAdaptor_HSurface& operator=(const BRepAdaptor_HSurface* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepAdaptor_HSurface* operator->() const
{
return (BRepAdaptor_HSurface *)ControlAccess();
}

static const Handle_BRepAdaptor_HSurface DownCast(const Handle_Standard_Transient& AnObject);
};
# 81 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_Adaptor3d_TopolTool.hxx” 1
# 36 “/usr/include/opencascade/Handle_Adaptor3d_TopolTool.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Adaptor3d_TopolTool;
Handle_Standard_Type& Adaptor3d_TopolTool_Type_();

class Handle_Adaptor3d_TopolTool : public Handle_MMgt_TShared {
public:
Handle_Adaptor3d_TopolTool():Handle_MMgt_TShared() {}
Handle_Adaptor3d_TopolTool(const Handle_Adaptor3d_TopolTool& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Adaptor3d_TopolTool(const Adaptor3d_TopolTool* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Adaptor3d_TopolTool& operator=(const Handle_Adaptor3d_TopolTool& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Adaptor3d_TopolTool& operator=(const Adaptor3d_TopolTool* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Adaptor3d_TopolTool* operator->() const
{
return (Adaptor3d_TopolTool *)ControlAccess();
}

static const Handle_Adaptor3d_TopolTool DownCast(const Handle_Standard_Transient& AnObject);
};
# 84 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_BRepAdaptor_HCurve2d.hxx” 1
# 33 “/usr/include/opencascade/Handle_BRepAdaptor_HCurve2d.hxx”
# 1 “/usr/include/opencascade/Handle_Adaptor2d_HCurve2d.hxx” 1
# 36 “/usr/include/opencascade/Handle_Adaptor2d_HCurve2d.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Adaptor2d_HCurve2d;
Handle_Standard_Type& Adaptor2d_HCurve2d_Type_();

class Handle_Adaptor2d_HCurve2d : public Handle_MMgt_TShared {
public:
Handle_Adaptor2d_HCurve2d():Handle_MMgt_TShared() {}
Handle_Adaptor2d_HCurve2d(const Handle_Adaptor2d_HCurve2d& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Adaptor2d_HCurve2d(const Adaptor2d_HCurve2d* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Adaptor2d_HCurve2d& operator=(const Handle_Adaptor2d_HCurve2d& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Adaptor2d_HCurve2d& operator=(const Adaptor2d_HCurve2d* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Adaptor2d_HCurve2d* operator->() const
{
return (Adaptor2d_HCurve2d *)ControlAccess();
}

static const Handle_Adaptor2d_HCurve2d DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_BRepAdaptor_HCurve2d.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Adaptor2d_HCurve2d;
class BRepAdaptor_HCurve2d;
Handle_Standard_Type& BRepAdaptor_HCurve2d_Type_();

class Handle_BRepAdaptor_HCurve2d : public Handle_Adaptor2d_HCurve2d {
public:
Handle_BRepAdaptor_HCurve2d():Handle_Adaptor2d_HCurve2d() {}
Handle_BRepAdaptor_HCurve2d(const Handle_BRepAdaptor_HCurve2d& aHandle) : Handle_Adaptor2d_HCurve2d(aHandle)
{
}

Handle_BRepAdaptor_HCurve2d(const BRepAdaptor_HCurve2d* anItem) : Handle_Adaptor2d_HCurve2d((Adaptor2d_HCurve2d *)anItem)
{
}

Handle_BRepAdaptor_HCurve2d& operator=(const Handle_BRepAdaptor_HCurve2d& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepAdaptor_HCurve2d& operator=(const BRepAdaptor_HCurve2d* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepAdaptor_HCurve2d* operator->() const
{
return (BRepAdaptor_HCurve2d *)ControlAccess();
}

static const Handle_BRepAdaptor_HCurve2d DownCast(const Handle_Standard_Transient& AnObject);
};
# 87 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

# 1 “/usr/include/opencascade/Handle_BRepBlend_Line.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepBlend_Line.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class BRepBlend_Line;
Handle_Standard_Type& BRepBlend_Line_Type_();

class Handle_BRepBlend_Line : public Handle_MMgt_TShared {
public:
Handle_BRepBlend_Line():Handle_MMgt_TShared() {}
Handle_BRepBlend_Line(const Handle_BRepBlend_Line& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_BRepBlend_Line(const BRepBlend_Line* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_BRepBlend_Line& operator=(const Handle_BRepBlend_Line& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepBlend_Line& operator=(const BRepBlend_Line* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepBlend_Line* operator->() const
{
return (BRepBlend_Line *)ControlAccess();
}

static const Handle_BRepBlend_Line DownCast(const Handle_Standard_Transient& AnObject);
};
# 93 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2
# 104 “/usr/include/opencascade/ChFi3d_Builder.hxx”
# 1 “/usr/include/opencascade/Handle_BRepTopAdaptor_TopolTool.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepTopAdaptor_TopolTool.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Adaptor3d_TopolTool;
class BRepTopAdaptor_TopolTool;
Handle_Standard_Type& BRepTopAdaptor_TopolTool_Type_();

class Handle_BRepTopAdaptor_TopolTool : public Handle_Adaptor3d_TopolTool {
public:
Handle_BRepTopAdaptor_TopolTool():Handle_Adaptor3d_TopolTool() {}
Handle_BRepTopAdaptor_TopolTool(const Handle_BRepTopAdaptor_TopolTool& aHandle) : Handle_Adaptor3d_TopolTool(aHandle)
{
}

Handle_BRepTopAdaptor_TopolTool(const BRepTopAdaptor_TopolTool* anItem) : Handle_Adaptor3d_TopolTool((Adaptor3d_TopolTool *)anItem)
{
}

Handle_BRepTopAdaptor_TopolTool& operator=(const Handle_BRepTopAdaptor_TopolTool& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepTopAdaptor_TopolTool& operator=(const BRepTopAdaptor_TopolTool* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepTopAdaptor_TopolTool* operator->() const
{
return (BRepTopAdaptor_TopolTool *)ControlAccess();
}

static const Handle_BRepTopAdaptor_TopolTool DownCast(const Handle_Standard_Transient& AnObject);
};
# 105 “/usr/include/opencascade/ChFi3d_Builder.hxx” 2

class TopOpeBRepDS_HDataStructure;
class TopOpeBRepBuild_HBuilder;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_ConstructionError;
class TopoDS_Shape;
class TopoDS_Edge;
class ChFiDS_Spine;
class TopoDS_Vertex;
class TopTools_ListOfShape;
class Geom_Surface;
class ChFiDS_SurfData;
class ChFiDS_HElSpine;
class BRepAdaptor_HSurface;
class Adaptor3d_TopolTool;
class math_Vector;
class BRepAdaptor_HCurve2d;
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Blend_Function;
class Blend_FuncInv;
class Adaptor2d_HCurve2d;
class Blend_SurfRstFunction;
class Blend_SurfPointFuncInv;
class Blend_SurfCurvFuncInv;
class Blend_RstRstFunction;
class Blend_CurvPointFuncInv;
class ChFiDS_Stripe;
class BRepTopAdaptor_TopolTool;
class ChFiDS_SequenceOfSurfData;
class gp_Pnt2d;
class ChFiDS_ListOfStripe;
class ChFiDS_CommonPoint;
class TopoDS_Face;
class AppBlend_Approx;
class Geom2d_Curve;
# 160 “/usr/include/opencascade/ChFi3d_Builder.hxx”
class ChFi3d_Builder {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~ChFi3d_Builder(){Delete() ; }

void SetParams(const Standard_Real Tang,const Standard_Real Tesp,const Standard_Real T2d,const Standard_Real TApp3d,const Standard_Real TolApp2d,const Standard_Real Fleche) ;

void SetContinuity(const GeomAbs_Shape InternalContinuity,const Standard_Real AngularTolerance) ;

void Remove(const TopoDS_Edge& E) ;

Standard_Integer Contains(const TopoDS_Edge& E) const;

Standard_Integer Contains(const TopoDS_Edge& E,Standard_Integer& IndexInSpine) const;

Standard_Integer NbElements() const;

Handle_ChFiDS_Spine Value(const Standard_Integer I) const;

Standard_Real Length(const Standard_Integer IC) const;

TopoDS_Vertex FirstVertex(const Standard_Integer IC) const;

TopoDS_Vertex LastVertex(const Standard_Integer IC) const;

Standard_Real Abscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const;

Standard_Real RelativeAbscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const;

Standard_Boolean ClosedAndTangent(const Standard_Integer IC) const;

Standard_Boolean Closed(const Standard_Integer IC) const;

void Compute() ;

Standard_Boolean IsDone() const;

TopoDS_Shape Shape() const;

const TopTools_ListOfShape& Generated(const TopoDS_Shape& EouV) ;

Standard_Integer NbFaultyContours() const;

Standard_Integer FaultyContour(const Standard_Integer I) const;

Standard_Integer NbComputedSurfaces(const Standard_Integer IC) const;

Handle_Geom_Surface ComputedSurface(const Standard_Integer IC,const Standard_Integer IS) const;

Standard_Integer NbFaultyVertices() const;

TopoDS_Vertex FaultyVertex(const Standard_Integer IV) const;

Standard_Boolean HasResult() const;

TopoDS_Shape BadShape() const;

ChFiDS_ErrorStatus StripeStatus(const Standard_Integer IC) const;

void Reset() ;

Handle_TopOpeBRepBuild_HBuilder Builder() const;

Standard_Boolean SplitKPart(const Handle_ChFiDS_SurfData& Data,ChFiDS_SequenceOfSurfData& SetData,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Iedge,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,Standard_Boolean& Intf,Standard_Boolean& Intl) ;

Standard_Integer PerformTwoCornerbyInter(const Standard_Integer Index) ;

protected:

ChFi3d_Builder(const TopoDS_Shape& S,const Standard_Real Ta);

virtual void SimulKPart(const Handle_ChFiDS_SurfData& SD) const = 0;

virtual Standard_Boolean SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecOnS1,const Standard_Boolean RecOnS2,const math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl) = 0;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const TopAbs_Orientation Or2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const TopAbs_Orientation Or2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2,const math_Vector& Soldep) ;

Standard_Boolean SimulData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,Blend_Function& Func,Blend_FuncInv& FInv,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const math_Vector& Soldep,const Standard_Integer NbSecMin,const Standard_Boolean RecOnS1 = (Standard_Boolean) 0,const Standard_Boolean RecOnS2 = (Standard_Boolean) 0) ;

Standard_Boolean SimulData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& HGuide,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor2d_HCurve2d& PC2,const Handle_Adaptor3d_TopolTool& I2,Standard_Boolean& Decroch,Blend_SurfRstFunction& Func,Blend_FuncInv& FInv,Blend_SurfPointFuncInv& FInvP,Blend_SurfCurvFuncInv& FInvC,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const math_Vector& Soldep,const Standard_Integer NbSecMin,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst) ;

Standard_Boolean SimulData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& HGuide,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor2d_HCurve2d& PC1,const Handle_Adaptor3d_TopolTool& I1,Standard_Boolean& Decroch1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor2d_HCurve2d& PC2,const Handle_Adaptor3d_TopolTool& I2,Standard_Boolean& Decroch2,Blend_RstRstFunction& Func,Blend_SurfCurvFuncInv& FInv1,Blend_CurvPointFuncInv& FInvP1,Blend_SurfCurvFuncInv& FInv2,Blend_CurvPointFuncInv& FInvP2,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const math_Vector& Soldep,const Standard_Integer NbSecMin,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2) ;

virtual void SetRegul() = 0;

Standard_Boolean PerformElement(const Handle_ChFiDS_Spine& CElement) ;

void PerformExtremity(const Handle_ChFiDS_Spine& CElement) ;

void PerformSetOfSurf(Handle_ChFiDS_Stripe& S,const Standard_Boolean Simul = (Standard_Boolean) 0) ;

void PerformSetOfKPart(Handle_ChFiDS_Stripe& S,const Standard_Boolean Simul = (Standard_Boolean) 0) ;

void PerformSetOfKGen(Handle_ChFiDS_Stripe& S,const Standard_Boolean Simul = (Standard_Boolean) 0) ;

void Trunc(const Handle_ChFiDS_SurfData& SD,const Handle_ChFiDS_Spine& Spine,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_HSurface& S2,const Standard_Integer iedge,const Standard_Boolean isfirst,const Standard_Integer cntlFiOnS) ;

void CallPerformSurf(Handle_ChFiDS_Stripe& Stripe,const Standard_Boolean Simul,ChFiDS_SequenceOfSurfData& SeqSD,Handle_ChFiDS_SurfData& SD,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Handle_BRepAdaptor_HSurface& HS1,const Handle_BRepAdaptor_HSurface& HS3,const gp_Pnt2d& P1,const gp_Pnt2d& P3,Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HSurface& HS2,const Handle_BRepAdaptor_HSurface& HS4,const gp_Pnt2d& P2,const gp_Pnt2d& P4,Handle_Adaptor3d_TopolTool& I2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecOnS1,const Standard_Boolean RecOnS2,math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl,Handle_BRepAdaptor_HSurface& Surf1,Handle_BRepAdaptor_HSurface& Surf2) ;

virtual Standard_Boolean PerformSurf(ChFiDS_SequenceOfSurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecOnS1,const Standard_Boolean RecOnS2,const math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl) = 0;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const TopAbs_Orientation Or2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const TopAbs_Orientation Or2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2,const math_Vector& Soldep) ;

virtual void PerformTwoCorner(const Standard_Integer Index) = 0;

virtual void PerformThreeCorner(const Standard_Integer Index) = 0;

void PerformMoreThreeCorner(const Standard_Integer Index,const Standard_Integer nbcourb) ;

virtual void ExtentOneCorner(const TopoDS_Vertex& V,const Handle_ChFiDS_Stripe& S) = 0;

virtual void ExtentTwoCorner(const TopoDS_Vertex& V,const ChFiDS_ListOfStripe& LS) = 0;

virtual void ExtentThreeCorner(const TopoDS_Vertex& V,const ChFiDS_ListOfStripe& LS) = 0;

virtual Standard_Boolean PerformFirstSection(const Handle_ChFiDS_Spine& S,const Handle_ChFiDS_HElSpine& HGuide,const Standard_Integer Choix,Handle_BRepAdaptor_HSurface& S1,Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real Par,math_Vector& SolDep,TopAbs_State& Pos1,TopAbs_State& Pos2) const = 0;

Standard_Boolean SearchFace(const Handle_ChFiDS_Spine& Sp,const ChFiDS_CommonPoint& Pc,const TopoDS_Face& FRef,TopoDS_Face& FVoi) const;

Standard_Boolean StripeOrientations(const Handle_ChFiDS_Spine& Sp,TopAbs_Orientation& Or1,TopAbs_Orientation& Or2,Standard_Integer& ChoixConge) const;

Standard_Boolean ComputeData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,Blend_Function& Func,Blend_FuncInv& FInv,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl,Standard_Boolean& Gd1,Standard_Boolean& Gd2,Standard_Boolean& Gf1,Standard_Boolean& Gf2,const Standard_Boolean RecOnS1 = (Standard_Boolean) 0,const Standard_Boolean RecOnS2 = (Standard_Boolean) 0) ;

Standard_Boolean ComputeData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& HGuide,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor2d_HCurve2d& PC2,const Handle_Adaptor3d_TopolTool& I2,Standard_Boolean& Decroch,Blend_SurfRstFunction& Func,Blend_FuncInv& FInv,Blend_SurfPointFuncInv& FInvP,Blend_SurfCurvFuncInv& FInvC,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const math_Vector& Soldep,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst) ;

Standard_Boolean ComputeData(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& HGuide,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor2d_HCurve2d& PC1,const Handle_Adaptor3d_TopolTool& I1,Standard_Boolean& Decroch1,const Handle_Adaptor3d_HSurface& S2,const Handle_Adaptor2d_HCurve2d& PC2,const Handle_Adaptor3d_TopolTool& I2,Standard_Boolean& Decroch2,Blend_RstRstFunction& Func,Blend_SurfCurvFuncInv& FInv1,Blend_CurvPointFuncInv& FInvP1,Blend_SurfCurvFuncInv& FInv2,Blend_CurvPointFuncInv& FInvP2,const Standard_Real PFirst,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const math_Vector& Soldep,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2) ;

Standard_Boolean CompleteData(Handle_ChFiDS_SurfData& Data,Blend_Function& Func,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_HSurface& S2,const TopAbs_Orientation Or1,const Standard_Boolean Gd1,const Standard_Boolean Gd2,const Standard_Boolean Gf1,const Standard_Boolean Gf2,const Standard_Boolean Reversed = (Standard_Boolean) 0) ;

Standard_Boolean CompleteData(Handle_ChFiDS_SurfData& Data,Blend_SurfRstFunction& Func,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_HSurface& S2,const TopAbs_Orientation Or,const Standard_Boolean Reversed) ;

Standard_Boolean CompleteData(Handle_ChFiDS_SurfData& Data,Blend_RstRstFunction& Func,Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_HSurface& S2,const TopAbs_Orientation Or) ;

Standard_Boolean StoreData(Handle_ChFiDS_SurfData& Data,const AppBlend_Approx& Approx,const Handle_BRepBlend_Line& Lin,const Handle_Adaptor3d_HSurface& S1,const Handle_Adaptor3d_HSurface& S2,const TopAbs_Orientation Or1,const Standard_Boolean Gd1,const Standard_Boolean Gd2,const Standard_Boolean Gf1,const Standard_Boolean Gf2,const Standard_Boolean Reversed = (Standard_Boolean) 0) ;

Standard_Boolean CompleteData(Handle_ChFiDS_SurfData& Data,const Handle_Geom_Surface& Surfcoin,const Handle_Adaptor3d_HSurface& S1,const Handle_Geom2d_Curve& PC1,const Handle_Adaptor3d_HSurface& S2,const Handle_Geom2d_Curve& PC2,const TopAbs_Orientation Or,const Standard_Boolean On1,const Standard_Boolean Gd1,const Standard_Boolean Gd2,const Standard_Boolean Gf1,const Standard_Boolean Gf2) ;

Standard_Real tolappangle;
Standard_Real tolesp;
Standard_Real tol2d;
Standard_Real tolapp3d;
Standard_Real tolapp2d;
Standard_Real fleche;
GeomAbs_Shape myConti;
ChFiDS_Map myEFMap;
ChFiDS_Map myESoMap;
ChFiDS_Map myEShMap;
ChFiDS_Map myVFMap;
ChFiDS_Map myVEMap;
Handle_TopOpeBRepDS_HDataStructure myDS;
Handle_TopOpeBRepBuild_HBuilder myCoup;
ChFiDS_ListOfStripe myListStripe;
ChFiDS_StripeMap myVDataMap;
ChFiDS_Regularities myRegul;
ChFiDS_ListOfStripe badstripes;
TopTools_ListOfShape badvertices;
TopTools_DataMapOfShapeListOfInteger myEVIMap;
Standard_Boolean done;
Standard_Boolean hasresult;

private:

Standard_Boolean FaceTangency(const TopoDS_Edge& E0,const TopoDS_Edge& E1,const TopoDS_Vertex& V) const;

void PerformSetOfSurfOnElSpine(const Handle_ChFiDS_HElSpine& ES,Handle_ChFiDS_Stripe& St,Handle_BRepTopAdaptor_TopolTool& It1,Handle_BRepTopAdaptor_TopolTool& It2,const Standard_Boolean Simul = (Standard_Boolean) 0) ;

void PerformFilletOnVertex(const Standard_Integer Index) ;

void PerformSingularCorner(const Standard_Integer Index) ;

void PerformOneCorner(const Standard_Integer Index,const Standard_Boolean PrepareOnSame = (Standard_Boolean) 0) ;

void IntersectMoreCorner(const Standard_Integer Index) ;

void PerformMoreSurfdata(const Standard_Integer Index) ;

void PerformIntersectionAtEnd(const Standard_Integer Index) ;

void ExtentAnalyse() ;

Standard_Boolean FindFace(const TopoDS_Vertex& V,const ChFiDS_CommonPoint& P1,const ChFiDS_CommonPoint& P2,TopoDS_Face& Fv) const;

Standard_Boolean FindFace(const TopoDS_Vertex& V,const ChFiDS_CommonPoint& P1,const ChFiDS_CommonPoint& P2,TopoDS_Face& Fv,const TopoDS_Face& Favoid) const;

Standard_Boolean MoreSurfdata(const Standard_Integer Index) const;

Standard_Boolean StartSol(const Handle_ChFiDS_Spine& Spine,Handle_BRepAdaptor_HSurface& HS,gp_Pnt2d& P,Handle_BRepAdaptor_HCurve2d& HC,Standard_Real& W,const Handle_ChFiDS_SurfData& SD,const Standard_Boolean isFirst,const Standard_Integer OnS,Handle_BRepAdaptor_HSurface& HSref,Handle_BRepAdaptor_HCurve2d& HCref,Standard_Boolean& RecP,Standard_Boolean& RecS,Standard_Boolean& RecRst,Standard_Boolean& C1Obst,Handle_BRepAdaptor_HSurface& HSbis,gp_Pnt2d& Pbis,const Standard_Boolean Decroch,const TopoDS_Vertex& Vref) const;

void StartSol(const Handle_ChFiDS_Stripe& S,const Handle_ChFiDS_HElSpine& HGuide,Handle_BRepAdaptor_HSurface& HS1,Handle_BRepAdaptor_HSurface& HS2,Handle_BRepTopAdaptor_TopolTool& I1,Handle_BRepTopAdaptor_TopolTool& I2,gp_Pnt2d& P1,gp_Pnt2d& P2,Standard_Real& First) const;

void ConexFaces(const Handle_ChFiDS_Spine& Sp,const Standard_Integer IEdge,const Standard_Integer RefChoix,Handle_BRepAdaptor_HSurface& HS1,Handle_BRepAdaptor_HSurface& HS2) const;

TopoDS_Shape myShape;
Standard_Real angular;
TopTools_ListOfShape myGenerated;
TopoDS_Shape myShapeResult;
TopoDS_Shape badShape;

};
# 30 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 2

# 1 “/usr/include/opencascade/ChFi3d_FilletShape.hxx” 1
# 26 “/usr/include/opencascade/ChFi3d_FilletShape.hxx”
enum ChFi3d_FilletShape {
ChFi3d_Rational,
ChFi3d_QuasiAngular,
ChFi3d_Polynomial
};
# 33 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 2

# 1 “/usr/include/opencascade/Handle_Law_Function.hxx” 1
# 36 “/usr/include/opencascade/Handle_Law_Function.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Law_Function;
Handle_Standard_Type& Law_Function_Type_();

class Handle_Law_Function : public Handle_MMgt_TShared {
public:
Handle_Law_Function():Handle_MMgt_TShared() {}
Handle_Law_Function(const Handle_Law_Function& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Law_Function(const Law_Function* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Law_Function& operator=(const Handle_Law_Function& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Law_Function& operator=(const Law_Function* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Law_Function* operator->() const
{
return (Law_Function *)ControlAccess();
}

static const Handle_Law_Function DownCast(const Handle_Standard_Transient& AnObject);
};
# 39 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 2
# 47 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx”
# 1 “/usr/include/opencascade/Handle_ChFiDS_SecHArray1.hxx” 1
# 36 “/usr/include/opencascade/Handle_ChFiDS_SecHArray1.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class ChFiDS_SecHArray1;
Handle_Standard_Type& ChFiDS_SecHArray1_Type_();

class Handle_ChFiDS_SecHArray1 : public Handle_MMgt_TShared {
public:
Handle_ChFiDS_SecHArray1():Handle_MMgt_TShared() {}
Handle_ChFiDS_SecHArray1(const Handle_ChFiDS_SecHArray1& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_ChFiDS_SecHArray1(const ChFiDS_SecHArray1* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_ChFiDS_SecHArray1& operator=(const Handle_ChFiDS_SecHArray1& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_ChFiDS_SecHArray1& operator=(const ChFiDS_SecHArray1* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

ChFiDS_SecHArray1* operator->() const
{
return (ChFiDS_SecHArray1 *)ControlAccess();
}

static const Handle_ChFiDS_SecHArray1 DownCast(const Handle_Standard_Transient& AnObject);
};
# 48 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx” 2
# 79 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx”
class TopoDS_Shape;
class TopoDS_Edge;
class Law_Function;
class TopoDS_Vertex;
class gp_XY;
class ChFiDS_SecHArray1;
class ChFiDS_SurfData;
class ChFiDS_HElSpine;
class ChFiDS_Spine;
class BRepAdaptor_HSurface;
class Adaptor3d_TopolTool;
class math_Vector;
class BRepAdaptor_HCurve2d;
class ChFiDS_SequenceOfSurfData;
class BRepBlend_Line;
class ChFiDS_Stripe;
class ChFiDS_ListOfStripe;
# 106 “/usr/include/opencascade/ChFi3d_FilBuilder.hxx”
class ChFi3d_FilBuilder : public ChFi3d_Builder {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

ChFi3d_FilBuilder(const TopoDS_Shape& S,const ChFi3d_FilletShape FShape = ChFi3d_Rational,const Standard_Real Ta = 1.0e-2);

void SetFilletShape(const ChFi3d_FilletShape FShape) ;

ChFi3d_FilletShape GetFilletShape() const;

void Add(const TopoDS_Edge& E) ;

void Add(const Standard_Real Radius,const TopoDS_Edge& E) ;

void SetRadius(const Handle_Law_Function& C,const Standard_Integer IC,const Standard_Integer IinC) ;

Standard_Boolean IsConstant(const Standard_Integer IC) ;

Standard_Real Radius(const Standard_Integer IC) ;

void ResetContour(const Standard_Integer IC) ;

void SetRadius(const Standard_Real Radius,const Standard_Integer IC,const TopoDS_Edge& E) ;

void UnSet(const Standard_Integer IC,const TopoDS_Edge& E) ;

void SetRadius(const Standard_Real Radius,const Standard_Integer IC,const TopoDS_Vertex& V) ;

void UnSet(const Standard_Integer IC,const TopoDS_Vertex& V) ;

void SetRadius(const gp_XY& UandR,const Standard_Integer IC,const Standard_Integer IinC) ;

Standard_Boolean IsConstant(const Standard_Integer IC,const TopoDS_Edge& E) ;

Standard_Real Radius(const Standard_Integer IC,const TopoDS_Edge& E) ;

Standard_Boolean GetBounds(const Standard_Integer IC,const TopoDS_Edge& E,Standard_Real& First,Standard_Real& Last) ;

Handle_Law_Function GetLaw(const Standard_Integer IC,const TopoDS_Edge& E) ;

void SetLaw(const Standard_Integer IC,const TopoDS_Edge& E,const Handle_Law_Function& L) ;

void Simulate(const Standard_Integer IC) ;

Standard_Integer NbSurf(const Standard_Integer IC) const;

Handle_ChFiDS_SecHArray1 Sect(const Standard_Integer IC,const Standard_Integer IS) const;

protected:

void SimulKPart(const Handle_ChFiDS_SurfData& SD) const;

Standard_Boolean SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecOnS1,const Standard_Boolean RecOnS2,const math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl) ;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const TopAbs_Orientation Or2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void SimulSurf(Handle_ChFiDS_SurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const TopAbs_Orientation Or2,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2,const math_Vector& Soldep) ;

Standard_Boolean PerformFirstSection(const Handle_ChFiDS_Spine& S,const Handle_ChFiDS_HElSpine& HGuide,const Standard_Integer Choix,Handle_BRepAdaptor_HSurface& S1,Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I1,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real Par,math_Vector& SolDep,TopAbs_State& Pos1,TopAbs_State& Pos2) const;

Standard_Boolean PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecOnS1,const Standard_Boolean RecOnS2,const math_Vector& Soldep,Standard_Boolean& Intf,Standard_Boolean& Intl) ;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const TopAbs_Orientation Or2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP,const Standard_Boolean RecS,const Standard_Boolean RecRst,const math_Vector& Soldep) ;

virtual void PerformSurf(ChFiDS_SequenceOfSurfData& Data,const Handle_ChFiDS_HElSpine& Guide,const Handle_ChFiDS_Spine& Spine,const Standard_Integer Choix,const Handle_BRepAdaptor_HSurface& S1,const Handle_Adaptor3d_TopolTool& I1,const Handle_BRepAdaptor_HCurve2d& PC1,const Handle_BRepAdaptor_HSurface& Sref1,const Handle_BRepAdaptor_HCurve2d& PCref1,Standard_Boolean& Decroch1,const TopAbs_Orientation Or1,const Handle_BRepAdaptor_HSurface& S2,const Handle_Adaptor3d_TopolTool& I2,const Handle_BRepAdaptor_HCurve2d& PC2,const Handle_BRepAdaptor_HSurface& Sref2,const Handle_BRepAdaptor_HCurve2d& PCref2,Standard_Boolean& Decroch2,const TopAbs_Orientation Or2,const Standard_Real MaxStep,const Standard_Real Fleche,const Standard_Real TolGuide,Standard_Real& First,Standard_Real& Last,const Standard_Boolean Inside,const Standard_Boolean Appro,const Standard_Boolean Forward,const Standard_Boolean RecP1,const Standard_Boolean RecRst1,const Standard_Boolean RecP2,const Standard_Boolean RecRst2,const math_Vector& Soldep) ;

void SplitSurf(ChFiDS_SequenceOfSurfData& SeqData,const Handle_BRepBlend_Line& line) ;

void PerformTwoCorner(const Standard_Integer Index) ;

void PerformThreeCorner(const Standard_Integer Index) ;

void ExtentOneCorner(const TopoDS_Vertex& V,const Handle_ChFiDS_Stripe& S) ;

void ExtentTwoCorner(const TopoDS_Vertex& V,const ChFiDS_ListOfStripe& LS) ;

void ExtentThreeCorner(const TopoDS_Vertex& V,const ChFiDS_ListOfStripe& LS) ;

void SetRegul() ;

private:

BlendFunc_SectionShape myShape;

};
# 27 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx” 2

# 1 “/usr/include/opencascade/BRepFilletAPI_LocalOperation.hxx” 1
# 40 “/usr/include/opencascade/BRepFilletAPI_LocalOperation.hxx”
class TopoDS_Edge;
class TopoDS_Vertex;
class ChFiDS_SecHArray1;
# 53 “/usr/include/opencascade/BRepFilletAPI_LocalOperation.hxx”
class BRepFilletAPI_LocalOperation : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Add(const TopoDS_Edge& E) = 0;

virtual void ResetContour(const Standard_Integer IC) = 0;

virtual Standard_Integer NbContours() const = 0;

virtual Standard_Integer Contour(const TopoDS_Edge& E) const = 0;

virtual Standard_Integer NbEdges(const Standard_Integer I) const = 0;

virtual const TopoDS_Edge& Edge(const Standard_Integer I,const Standard_Integer J) const = 0;

virtual void Remove(const TopoDS_Edge& E) = 0;

virtual Standard_Real Length(const Standard_Integer IC) const = 0;

virtual TopoDS_Vertex FirstVertex(const Standard_Integer IC) const = 0;

virtual TopoDS_Vertex LastVertex(const Standard_Integer IC) const = 0;

virtual Standard_Real Abscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const = 0;

virtual Standard_Real RelativeAbscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const = 0;

virtual Standard_Boolean ClosedAndTangent(const Standard_Integer IC) const = 0;

virtual Standard_Boolean Closed(const Standard_Integer IC) const = 0;

virtual void Reset() = 0;

virtual void Simulate(const Standard_Integer IC) = 0;

virtual Standard_Integer NbSurf(const Standard_Integer IC) const = 0;

virtual Handle_ChFiDS_SecHArray1 Sect(const Standard_Integer IC,const Standard_Integer IS) const = 0;

protected:
# 151 “/usr/include/opencascade/BRepFilletAPI_LocalOperation.hxx”
private:
# 161 “/usr/include/opencascade/BRepFilletAPI_LocalOperation.hxx”
};
# 33 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx” 2
# 64 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
class StdFail_NotDone;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopoDS_Edge;
class Law_Function;
class TColgp_Array1OfPnt2d;
class TopoDS_Vertex;
class TopOpeBRepBuild_HBuilder;
class TopTools_ListOfShape;
class ChFiDS_SecHArray1;
class Geom_Surface;
# 90 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
class BRepFilletAPI_MakeFillet : public BRepFilletAPI_LocalOperation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 117 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
BRepFilletAPI_MakeFillet(const TopoDS_Shape& S,const ChFi3d_FilletShape FShape = ChFi3d_Rational);

void SetParams(const Standard_Real Tang,const Standard_Real Tesp,const Standard_Real T2d,const Standard_Real TApp3d,const Standard_Real TolApp2d,const Standard_Real Fleche) ;

void SetContinuity(const GeomAbs_Shape InternalContinuity,const Standard_Real AngularTolerance) ;

void Add(const TopoDS_Edge& E) ;

void Add(const Standard_Real Radius,const TopoDS_Edge& E) ;

void Add(const Standard_Real R1,const Standard_Real R2,const TopoDS_Edge& E) ;

void Add(const Handle_Law_Function& L,const TopoDS_Edge& E) ;
# 163 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
void Add(const TColgp_Array1OfPnt2d& UandR,const TopoDS_Edge& E) ;

void SetRadius(const Standard_Real Radius,const Standard_Integer IC,const Standard_Integer IinC) ;

void SetRadius(const Standard_Real R1,const Standard_Real R2,const Standard_Integer IC,const Standard_Integer IinC) ;

void SetRadius(const Handle_Law_Function& L,const Standard_Integer IC,const Standard_Integer IinC) ;
# 196 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
void SetRadius(const TColgp_Array1OfPnt2d& UandR,const Standard_Integer IC,const Standard_Integer IinC) ;

void ResetContour(const Standard_Integer IC) ;

Standard_Boolean IsConstant(const Standard_Integer IC) ;

Standard_Real Radius(const Standard_Integer IC) ;

Standard_Boolean IsConstant(const Standard_Integer IC,const TopoDS_Edge& E) ;

Standard_Real Radius(const Standard_Integer IC,const TopoDS_Edge& E) ;

void SetRadius(const Standard_Real Radius,const Standard_Integer IC,const TopoDS_Edge& E) ;

void SetRadius(const Standard_Real Radius,const Standard_Integer IC,const TopoDS_Vertex& V) ;

Standard_Boolean GetBounds(const Standard_Integer IC,const TopoDS_Edge& E,Standard_Real& F,Standard_Real& L) ;

Handle_Law_Function GetLaw(const Standard_Integer IC,const TopoDS_Edge& E) ;

void SetLaw(const Standard_Integer IC,const TopoDS_Edge& E,const Handle_Law_Function& L) ;

void SetFilletShape(const ChFi3d_FilletShape FShape) ;

ChFi3d_FilletShape GetFilletShape() const;

Standard_Integer NbContours() const;

Standard_Integer Contour(const TopoDS_Edge& E) const;

Standard_Integer NbEdges(const Standard_Integer I) const;

const TopoDS_Edge& Edge(const Standard_Integer I,const Standard_Integer J) const;

void Remove(const TopoDS_Edge& E) ;

Standard_Real Length(const Standard_Integer IC) const;

TopoDS_Vertex FirstVertex(const Standard_Integer IC) const;

TopoDS_Vertex LastVertex(const Standard_Integer IC) const;

Standard_Real Abscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const;
# 323 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
Standard_Real RelativeAbscissa(const Standard_Integer IC,const TopoDS_Vertex& V) const;

Standard_Boolean ClosedAndTangent(const Standard_Integer IC) const;

Standard_Boolean Closed(const Standard_Integer IC) const;
# 356 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
virtual void Build() ;

void Reset() ;

Handle_TopOpeBRepBuild_HBuilder Builder() const;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& EorV) ;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& F) ;

virtual Standard_Boolean IsDeleted(const TopoDS_Shape& F) ;

Standard_Integer NbSurfaces() const;

const TopTools_ListOfShape& NewFaces(const Standard_Integer I) ;

void Simulate(const Standard_Integer IC) ;

Standard_Integer NbSurf(const Standard_Integer IC) const;

Handle_ChFiDS_SecHArray1 Sect(const Standard_Integer IC,const Standard_Integer IS) const;

Standard_Integer NbFaultyContours() const;

Standard_Integer FaultyContour(const Standard_Integer I) const;

Standard_Integer NbComputedSurfaces(const Standard_Integer IC) const;

Handle_Geom_Surface ComputedSurface(const Standard_Integer IC,const Standard_Integer IS) const;

Standard_Integer NbFaultyVertices() const;

TopoDS_Vertex FaultyVertex(const Standard_Integer IV) const;

Standard_Boolean HasResult() const;

TopoDS_Shape BadShape() const;
# 431 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
ChFiDS_ErrorStatus StripeStatus(const Standard_Integer IC) const;

protected:
# 447 “/usr/include/opencascade/BRepFilletAPI_MakeFillet.hxx”
private:

ChFi3d_FilBuilder myBuilder;
TopTools_MapOfShape myMap;

};
# 11 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepLib.hxx” 1
# 29 “/usr/include/opencascade/BRepLib.hxx”
# 1 “/usr/include/opencascade/Handle_Geom_Plane.hxx” 1
# 33 “/usr/include/opencascade/Handle_Geom_Plane.hxx”
# 1 “/usr/include/opencascade/Handle_Geom_ElementarySurface.hxx” 1
# 36 “/usr/include/opencascade/Handle_Geom_ElementarySurface.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_Surface;
class Geom_ElementarySurface;
Handle_Standard_Type& Geom_ElementarySurface_Type_();

class Handle_Geom_ElementarySurface : public Handle_Geom_Surface {
public:
Handle_Geom_ElementarySurface():Handle_Geom_Surface() {}
Handle_Geom_ElementarySurface(const Handle_Geom_ElementarySurface& aHandle) : Handle_Geom_Surface(aHandle)
{
}

Handle_Geom_ElementarySurface(const Geom_ElementarySurface* anItem) : Handle_Geom_Surface((Geom_Surface *)anItem)
{
}

Handle_Geom_ElementarySurface& operator=(const Handle_Geom_ElementarySurface& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_ElementarySurface& operator=(const Geom_ElementarySurface* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_ElementarySurface* operator->() const
{
return (Geom_ElementarySurface *)ControlAccess();
}

static const Handle_Geom_ElementarySurface DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom_Plane.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_ElementarySurface;
class Geom_Plane;
Handle_Standard_Type& Geom_Plane_Type_();

class Handle_Geom_Plane : public Handle_Geom_ElementarySurface {
public:
Handle_Geom_Plane():Handle_Geom_ElementarySurface() {}
Handle_Geom_Plane(const Handle_Geom_Plane& aHandle) : Handle_Geom_ElementarySurface(aHandle)
{
}

Handle_Geom_Plane(const Geom_Plane* anItem) : Handle_Geom_ElementarySurface((Geom_ElementarySurface *)anItem)
{
}

Handle_Geom_Plane& operator=(const Handle_Geom_Plane& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Plane& operator=(const Geom_Plane* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Plane* operator->() const
{
return (Geom_Plane *)ControlAccess();
}

static const Handle_Geom_Plane DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/BRepLib.hxx” 2
# 40 “/usr/include/opencascade/BRepLib.hxx”
class Geom_Plane;
class TopoDS_Edge;
class TopoDS_Shape;
class TopoDS_Solid;
class TopoDS_Face;
class TopTools_ListOfShape;
class BRepLib_Command;
class BRepLib_MakeShape;
class BRepLib_MakeVertex;
class BRepLib_MakeEdge;
class BRepLib_MakeEdge2d;
class BRepLib_MakePolygon;
class BRepLib_MakeFace;
class BRepLib_MakeWire;
class BRepLib_MakeShell;
class BRepLib_MakeSolid;
class BRepLib_FindSurface;
# 73 “/usr/include/opencascade/BRepLib.hxx”
class BRepLib {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

static void Precision(const Standard_Real P) ;

static Standard_Real Precision() ;

static void Plane(const Handle_Geom_Plane& P) ;

static const Handle_Geom_Plane& Plane() ;

static Standard_Boolean CheckSameRange(const TopoDS_Edge& E,const Standard_Real Confusion = 1.0e-12) ;
# 121 “/usr/include/opencascade/BRepLib.hxx”
static void SameRange(const TopoDS_Edge& E,const Standard_Real Tolerance = 1.0e-5) ;

static Standard_Boolean BuildCurve3d(const TopoDS_Edge& E,const Standard_Real Tolerance = 1.0e-5,const GeomAbs_Shape Continuity = GeomAbs_C1,const Standard_Integer MaxDegree = 14,const Standard_Integer MaxSegment = 0) ;

static Standard_Boolean BuildCurves3d(const TopoDS_Shape& S,const Standard_Real Tolerance,const GeomAbs_Shape Continuity = GeomAbs_C1,const Standard_Integer MaxDegree = 14,const Standard_Integer MaxSegment = 0) ;

static Standard_Boolean BuildCurves3d(const TopoDS_Shape& S) ;

static Standard_Boolean UpdateEdgeTol(const TopoDS_Edge& E,const Standard_Real MinToleranceRequest,const Standard_Real MaxToleranceToCheck) ;

static Standard_Boolean UpdateEdgeTolerance(const TopoDS_Shape& S,const Standard_Real MinToleranceRequest,const Standard_Real MaxToleranceToCheck) ;

static void SameParameter(const TopoDS_Edge& E,const Standard_Real Tolerance = 1.0e-5) ;

static void SameParameter(const TopoDS_Shape& S,const Standard_Real Tolerance = 1.0e-5,const Standard_Boolean forced = (Standard_Boolean) 0) ;

static void UpdateTolerances(const TopoDS_Shape& S,const Standard_Boolean verifyFaceTolerance = (Standard_Boolean) 0) ;

static Standard_Boolean OrientClosedSolid(TopoDS_Solid& solid) ;

static void EncodeRegularity(const TopoDS_Shape& S,const Standard_Real TolAng = 1.0e-10) ;

static void EncodeRegularity(TopoDS_Edge& S,const TopoDS_Face& F1,const TopoDS_Face& F2,const Standard_Real TolAng = 1.0e-10) ;

static void SortFaces(const TopoDS_Shape& S,TopTools_ListOfShape& LF) ;

static void ReverseSortFaces(const TopoDS_Shape& S,TopTools_ListOfShape& LF) ;

protected:
# 202 “/usr/include/opencascade/BRepLib.hxx”
private:
# 211 “/usr/include/opencascade/BRepLib.hxx”
friend class BRepLib_Command;
friend class BRepLib_MakeShape;
friend class BRepLib_MakeVertex;
friend class BRepLib_MakeEdge;
friend class BRepLib_MakeEdge2d;
friend class BRepLib_MakePolygon;
friend class BRepLib_MakeFace;
friend class BRepLib_MakeWire;
friend class BRepLib_MakeShell;
friend class BRepLib_MakeSolid;
friend class BRepLib_FindSurface;

};
# 13 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx” 1
# 26 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
# 1 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx” 1
# 26 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx”
# 1 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 1
# 32 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx”
# 1 “/usr/include/opencascade/BRepOffset_Mode.hxx” 1
# 26 “/usr/include/opencascade/BRepOffset_Mode.hxx”
enum BRepOffset_Mode {
BRepOffset_Skin,
BRepOffset_Pipe,
BRepOffset_RectoVerso
};
# 33 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/GeomAbs_JoinType.hxx” 1
# 27 “/usr/include/opencascade/GeomAbs_JoinType.hxx”
enum GeomAbs_JoinType {
GeomAbs_Arc,
GeomAbs_Tangent,
GeomAbs_Intersection
};
# 39 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/BRepOffset_DataMapOfShapeReal.hxx” 1
# 32 “/usr/include/opencascade/BRepOffset_DataMapOfShapeReal.hxx”
# 1 “/usr/include/opencascade/Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class BRepOffset_DataMapNodeOfDataMapOfShapeReal;
Handle_Standard_Type& BRepOffset_DataMapNodeOfDataMapOfShapeReal_Type_();

class Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal : public Handle_TCollection_MapNode {
public:
Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal():Handle_TCollection_MapNode() {}
Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal(const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal(const BRepOffset_DataMapNodeOfDataMapOfShapeReal* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal& operator=(const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal& operator=(const BRepOffset_DataMapNodeOfDataMapOfShapeReal* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepOffset_DataMapNodeOfDataMapOfShapeReal* operator->() const
{
return (BRepOffset_DataMapNodeOfDataMapOfShapeReal *)ControlAccess();
}

static const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeReal DownCast(const Handle_Standard_Transient& AnObject);
};
# 33 “/usr/include/opencascade/BRepOffset_DataMapOfShapeReal.hxx” 2

class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopTools_ShapeMapHasher;
class BRepOffset_DataMapNodeOfDataMapOfShapeReal;
class BRepOffset_DataMapIteratorOfDataMapOfShapeReal;
# 56 “/usr/include/opencascade/BRepOffset_DataMapOfShapeReal.hxx”
class BRepOffset_DataMapOfShapeReal : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffset_DataMapOfShapeReal(const Standard_Integer NbBuckets = 1);

BRepOffset_DataMapOfShapeReal& Assign(const BRepOffset_DataMapOfShapeReal& Other) ;
BRepOffset_DataMapOfShapeReal& operator =(const BRepOffset_DataMapOfShapeReal& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~BRepOffset_DataMapOfShapeReal()
{
Clear();
}

Standard_Boolean Bind(const TopoDS_Shape& K,const Standard_Real& I) ;

Standard_Boolean IsBound(const TopoDS_Shape& K) const;

Standard_Boolean UnBind(const TopoDS_Shape& K) ;

const Standard_Real& Find(const TopoDS_Shape& K) const;
const Standard_Real& operator()(const TopoDS_Shape& K) const
{
return Find(K);
}

Standard_Real& ChangeFind(const TopoDS_Shape& K) ;
Standard_Real& operator()(const TopoDS_Shape& K)
{
return ChangeFind(K);
}

protected:
# 136 “/usr/include/opencascade/BRepOffset_DataMapOfShapeReal.hxx”
private:

BRepOffset_DataMapOfShapeReal(const BRepOffset_DataMapOfShapeReal& Other);

};
# 42 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/BRepOffset_Analyse.hxx” 1
# 32 “/usr/include/opencascade/BRepOffset_Analyse.hxx”
# 1 “/usr/include/opencascade/BRepOffset_DataMapOfShapeListOfInterval.hxx” 1
# 29 “/usr/include/opencascade/BRepOffset_DataMapOfShapeListOfInterval.hxx”
# 1 “/usr/include/opencascade/Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval;
Handle_Standard_Type& BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval_Type_();

class Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval : public Handle_TCollection_MapNode {
public:
Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval():Handle_TCollection_MapNode() {}
Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval(const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval(const BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval& operator=(const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval& operator=(const BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval* operator->() const
{
return (BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval *)ControlAccess();
}

static const Handle_BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/BRepOffset_DataMapOfShapeListOfInterval.hxx” 2

class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Shape;
class BRepOffset_ListOfInterval;
class TopTools_ShapeMapHasher;
class BRepOffset_DataMapNodeOfDataMapOfShapeListOfInterval;
class BRepOffset_DataMapIteratorOfDataMapOfShapeListOfInterval;
# 54 “/usr/include/opencascade/BRepOffset_DataMapOfShapeListOfInterval.hxx”
class BRepOffset_DataMapOfShapeListOfInterval : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffset_DataMapOfShapeListOfInterval(const Standard_Integer NbBuckets = 1);

BRepOffset_DataMapOfShapeListOfInterval& Assign(const BRepOffset_DataMapOfShapeListOfInterval& Other) ;
BRepOffset_DataMapOfShapeListOfInterval& operator =(const BRepOffset_DataMapOfShapeListOfInterval& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~BRepOffset_DataMapOfShapeListOfInterval()
{
Clear();
}

Standard_Boolean Bind(const TopoDS_Shape& K,const BRepOffset_ListOfInterval& I) ;

Standard_Boolean IsBound(const TopoDS_Shape& K) const;

Standard_Boolean UnBind(const TopoDS_Shape& K) ;

const BRepOffset_ListOfInterval& Find(const TopoDS_Shape& K) const;
const BRepOffset_ListOfInterval& operator()(const TopoDS_Shape& K) const
{
return Find(K);
}

BRepOffset_ListOfInterval& ChangeFind(const TopoDS_Shape& K) ;
BRepOffset_ListOfInterval& operator()(const TopoDS_Shape& K)
{
return ChangeFind(K);
}

protected:
# 134 “/usr/include/opencascade/BRepOffset_DataMapOfShapeListOfInterval.hxx”
private:

BRepOffset_DataMapOfShapeListOfInterval(const BRepOffset_DataMapOfShapeListOfInterval& Other);

};
# 33 “/usr/include/opencascade/BRepOffset_Analyse.hxx” 2
# 41 “/usr/include/opencascade/BRepOffset_Analyse.hxx”
# 1 “/usr/include/opencascade/BRepOffset_Type.hxx” 1
# 26 “/usr/include/opencascade/BRepOffset_Type.hxx”
enum BRepOffset_Type {
BRepOffset_Concave,
BRepOffset_Convex,
BRepOffset_Tangent,
BRepOffset_FreeBoundary,
BRepOffset_Other
};
# 42 “/usr/include/opencascade/BRepOffset_Analyse.hxx” 2

class TopoDS_Shape;
class BRepOffset_ListOfInterval;
class TopoDS_Edge;
class TopoDS_Vertex;
class TopTools_ListOfShape;
class TopoDS_Face;
class TopoDS_Compound;
class TopTools_MapOfShape;
# 62 “/usr/include/opencascade/BRepOffset_Analyse.hxx”
class BRepOffset_Analyse {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffset_Analyse();

BRepOffset_Analyse(const TopoDS_Shape& S,const Standard_Real Angle);

void Perform(const TopoDS_Shape& S,const Standard_Real Angle) ;

Standard_Boolean IsDone() const;

void Clear() ;

const BRepOffset_ListOfInterval& Type(const TopoDS_Edge& E) const;

void Edges(const TopoDS_Vertex& V,const BRepOffset_Type T,TopTools_ListOfShape& L) const;

void Edges(const TopoDS_Face& F,const BRepOffset_Type T,TopTools_ListOfShape& L) const;

void TangentEdges(const TopoDS_Edge& Edge,const TopoDS_Vertex& Vertex,TopTools_ListOfShape& Edges) const;

Standard_Boolean HasAncestor(const TopoDS_Shape& S) const;

const TopTools_ListOfShape& Ancestors(const TopoDS_Shape& S) const;

void Explode(TopTools_ListOfShape& L,const BRepOffset_Type Type) const;

void Explode(TopTools_ListOfShape& L,const BRepOffset_Type Type1,const BRepOffset_Type Type2) const;

void AddFaces(const TopoDS_Face& Face,TopoDS_Compound& Co,TopTools_MapOfShape& Map,const BRepOffset_Type Type) const;

void AddFaces(const TopoDS_Face& Face,TopoDS_Compound& Co,TopTools_MapOfShape& Map,const BRepOffset_Type Type1,const BRepOffset_Type Type2) const;

protected:
# 147 “/usr/include/opencascade/BRepOffset_Analyse.hxx”
private:

Standard_Boolean myDone;
TopoDS_Shape myShape;
BRepOffset_DataMapOfShapeListOfInterval mapEdgeType;
TopTools_IndexedDataMapOfShapeListOfShape ancestors;
Standard_Real angle;

};
# 48 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/BRepAlgo_Image.hxx” 1
# 32 “/usr/include/opencascade/BRepAlgo_Image.hxx”
# 1 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_DataMapNodeOfDataMapOfShapeListOfShape;
Handle_Standard_Type& TopTools_DataMapNodeOfDataMapOfShapeListOfShape_Type_();

class Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape(const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape(const TopTools_DataMapNodeOfDataMapOfShapeListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape& operator=(const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape& operator=(const TopTools_DataMapNodeOfDataMapOfShapeListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_DataMapNodeOfDataMapOfShapeListOfShape* operator->() const
{
return (TopTools_DataMapNodeOfDataMapOfShapeListOfShape *)ControlAccess();
}

static const Handle_TopTools_DataMapNodeOfDataMapOfShapeListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfShape.hxx” 2

class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Shape;
class TopTools_ListOfShape;
class TopTools_ShapeMapHasher;
class TopTools_DataMapNodeOfDataMapOfShapeListOfShape;
class TopTools_DataMapIteratorOfDataMapOfShapeListOfShape;
# 54 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfShape.hxx”
class TopTools_DataMapOfShapeListOfShape : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_DataMapOfShapeListOfShape(const Standard_Integer NbBuckets = 1);

TopTools_DataMapOfShapeListOfShape& Assign(const TopTools_DataMapOfShapeListOfShape& Other) ;
TopTools_DataMapOfShapeListOfShape& operator =(const TopTools_DataMapOfShapeListOfShape& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_DataMapOfShapeListOfShape()
{
Clear();
}

Standard_Boolean Bind(const TopoDS_Shape& K,const TopTools_ListOfShape& I) ;

Standard_Boolean IsBound(const TopoDS_Shape& K) const;

Standard_Boolean UnBind(const TopoDS_Shape& K) ;

const TopTools_ListOfShape& Find(const TopoDS_Shape& K) const;
const TopTools_ListOfShape& operator()(const TopoDS_Shape& K) const
{
return Find(K);
}

TopTools_ListOfShape& ChangeFind(const TopoDS_Shape& K) ;
TopTools_ListOfShape& operator()(const TopoDS_Shape& K)
{
return ChangeFind(K);
}

protected:
# 134 “/usr/include/opencascade/TopTools_DataMapOfShapeListOfShape.hxx”
private:

TopTools_DataMapOfShapeListOfShape(const TopTools_DataMapOfShapeListOfShape& Other);

};
# 33 “/usr/include/opencascade/BRepAlgo_Image.hxx” 2

class Standard_ConstructionError;
class TopoDS_Shape;
class TopTools_ListOfShape;
# 54 “/usr/include/opencascade/BRepAlgo_Image.hxx”
class BRepAlgo_Image {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepAlgo_Image();

void SetRoot(const TopoDS_Shape& S) ;

void Bind(const TopoDS_Shape& OldS,const TopoDS_Shape& NewS) ;

void Bind(const TopoDS_Shape& OldS,const TopTools_ListOfShape& NewS) ;

void Add(const TopoDS_Shape& OldS,const TopoDS_Shape& NewS) ;

void Add(const TopoDS_Shape& OldS,const TopTools_ListOfShape& NewS) ;

void Clear() ;

void Remove(const TopoDS_Shape& S) ;

const TopTools_ListOfShape& Roots() const;

Standard_Boolean IsImage(const TopoDS_Shape& S) const;

const TopoDS_Shape& ImageFrom(const TopoDS_Shape& S) const;

const TopoDS_Shape& Root(const TopoDS_Shape& S) const;

Standard_Boolean HasImage(const TopoDS_Shape& S) const;

const TopTools_ListOfShape& Image(const TopoDS_Shape& S) const;

void LastImage(const TopoDS_Shape& S,TopTools_ListOfShape& L) const;

void Compact() ;

void Filter(const TopoDS_Shape& S,const TopAbs_ShapeEnum ShapeType) ;

protected:
# 142 “/usr/include/opencascade/BRepAlgo_Image.hxx”
private:

TopTools_ListOfShape roots;
TopTools_DataMapOfShapeShape up;
TopTools_DataMapOfShapeListOfShape down;

};
# 51 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/Handle_BRepAlgo_AsDes.hxx” 1
# 36 “/usr/include/opencascade/Handle_BRepAlgo_AsDes.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class BRepAlgo_AsDes;
Handle_Standard_Type& BRepAlgo_AsDes_Type_();

class Handle_BRepAlgo_AsDes : public Handle_MMgt_TShared {
public:
Handle_BRepAlgo_AsDes():Handle_MMgt_TShared() {}
Handle_BRepAlgo_AsDes(const Handle_BRepAlgo_AsDes& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_BRepAlgo_AsDes(const BRepAlgo_AsDes* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_BRepAlgo_AsDes& operator=(const Handle_BRepAlgo_AsDes& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BRepAlgo_AsDes& operator=(const BRepAlgo_AsDes* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BRepAlgo_AsDes* operator->() const
{
return (BRepAlgo_AsDes *)ControlAccess();
}

static const Handle_BRepAlgo_AsDes DownCast(const Handle_Standard_Transient& AnObject);
};
# 54 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/BRepOffset_Error.hxx” 1
# 26 “/usr/include/opencascade/BRepOffset_Error.hxx”
enum BRepOffset_Error {
BRepOffset_NoError,
BRepOffset_OffsetSurfaceFailed,
BRepOffset_UnCorrectClosingFace,
BRepOffset_ExtentFaceFailed,
BRepOffset_RadiusEqualOffset,
BRepOffset_UnknownError
};
# 57 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

# 1 “/usr/include/opencascade/BRepOffset_MakeLoops.hxx” 1
# 34 “/usr/include/opencascade/BRepOffset_MakeLoops.hxx”
class TopTools_ListOfShape;
class BRepAlgo_AsDes;
class BRepAlgo_Image;
class BRepOffset_Analyse;
# 48 “/usr/include/opencascade/BRepOffset_MakeLoops.hxx”
class BRepOffset_MakeLoops {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffset_MakeLoops();

void Build(const TopTools_ListOfShape& LF,const Handle_BRepAlgo_AsDes& AsDes,BRepAlgo_Image& Image) ;

void BuildOnContext(const TopTools_ListOfShape& LContext,const BRepOffset_Analyse& Analyse,const Handle_BRepAlgo_AsDes& AsDes,BRepAlgo_Image& Image,const Standard_Boolean InSide) ;

void BuildFaces(const TopTools_ListOfShape& LF,const Handle_BRepAlgo_AsDes& AsDes,BRepAlgo_Image& Image) ;

protected:
# 93 “/usr/include/opencascade/BRepOffset_MakeLoops.hxx”
private:

TopTools_DataMapOfShapeShape myVerVerMap;

};
# 60 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx” 2

class BRepAlgo_AsDes;
class TopoDS_Shape;
class TopoDS_Face;
class BRepOffset_Analyse;
class BRepAlgo_Image;
class TopTools_MapOfShape;
class BRepOffset_Inter3d;
class BRepOffset_DataMapOfShapeOffset;
# 79 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx”
class BRepOffset_MakeOffset {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffset_MakeOffset();

BRepOffset_MakeOffset(const TopoDS_Shape& S,const Standard_Real Offset,const Standard_Real Tol,const BRepOffset_Mode Mode = BRepOffset_Skin,const Standard_Boolean Intersection = (Standard_Boolean) 0,const Standard_Boolean SelfInter = (Standard_Boolean) 0,const GeomAbs_JoinType Join = GeomAbs_Arc);

void Initialize(const TopoDS_Shape& S,const Standard_Real Offset,const Standard_Real Tol,const BRepOffset_Mode Mode = BRepOffset_Skin,const Standard_Boolean Intersection = (Standard_Boolean) 0,const Standard_Boolean SelfInter = (Standard_Boolean) 0,const GeomAbs_JoinType Join = GeomAbs_Arc) ;

void Clear() ;

void AddFace(const TopoDS_Face& F) ;

void SetOffsetOnFace(const TopoDS_Face& F,const Standard_Real Off) ;

void MakeOffsetShape() ;

void MakeThickSolid() ;

const BRepOffset_Analyse& GetAnalyse() const;

Standard_Boolean IsDone() const;

const TopoDS_Shape& Shape() const;

BRepOffset_Error Error() const;

const BRepAlgo_Image& OffsetFacesFromShapes() const;

GeomAbs_JoinType GetJoinType() const;

const BRepAlgo_Image& OffsetEdgesFromShapes() const;

const TopTools_MapOfShape& ClosingFaces() const;

protected:
# 163 “/usr/include/opencascade/BRepOffset_MakeOffset.hxx”
private:

void BuildOffsetByArc() ;

void BuildOffsetByInter() ;

void SelfInter(TopTools_MapOfShape& Modif) ;

void Intersection3D(BRepOffset_Inter3d& Inter) ;

void Intersection2D(const TopTools_MapOfShape& Modif,const TopTools_MapOfShape& NewEdges) ;

void MakeLoops(TopTools_MapOfShape& Modif) ;

void MakeLoopsOnContext(TopTools_MapOfShape& Modif) ;

void MakeFaces(TopTools_MapOfShape& Modif) ;

void MakeShells() ;

void SelectShells() ;

void EncodeRegularity() ;

void MakeSolid() ;

void ToContext(BRepOffset_DataMapOfShapeOffset& MapSF) ;

void UpdateFaceOffset() ;

void CorrectConicalFaces() ;

Standard_Real myOffset;
Standard_Real myTol;
TopoDS_Shape myShape;
BRepOffset_Mode myMode;
Standard_Boolean myInter;
Standard_Boolean mySelfInter;
GeomAbs_JoinType myJoin;
BRepOffset_DataMapOfShapeReal myFaceOffset;
TopTools_MapOfShape myFaces;
BRepOffset_Analyse myAnalyse;
TopoDS_Shape myOffsetShape;
BRepAlgo_Image myInitOffsetFace;
BRepAlgo_Image myInitOffsetEdge;
BRepAlgo_Image myImageOffset;
Handle_BRepAlgo_AsDes myAsDes;
Standard_Boolean myDone;
BRepOffset_Error myError;
BRepOffset_MakeLoops myMakeLoops;

};
# 27 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx” 2
# 43 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx”
class TopoDS_Shape;
class BRepOffset_MakeOffset;
class TopTools_ListOfShape;
# 61 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx”
class BRepOffsetAPI_MakeOffsetShape : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffsetAPI_MakeOffsetShape();
# 136 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx”
BRepOffsetAPI_MakeOffsetShape(const TopoDS_Shape& S,const Standard_Real Offset,const Standard_Real Tol,const BRepOffset_Mode Mode = BRepOffset_Skin,const Standard_Boolean Intersection = (Standard_Boolean) 0,const Standard_Boolean SelfInter = (Standard_Boolean) 0,const GeomAbs_JoinType Join = GeomAbs_Arc);

virtual const BRepOffset_MakeOffset& MakeOffset() const;

virtual void Build() ;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;

const TopTools_ListOfShape& GeneratedEdge(const TopoDS_Shape& S) ;

GeomAbs_JoinType GetJoinType() const;

protected:

BRepOffset_MakeOffset myOffsetShape;

private:
# 179 “/usr/include/opencascade/BRepOffsetAPI_MakeOffsetShape.hxx”
};
# 27 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx” 2
# 40 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
class TopoDS_Shape;
class TopTools_ListOfShape;
# 66 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
class BRepOffsetAPI_MakeThickSolid : public BRepOffsetAPI_MakeOffsetShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepOffsetAPI_MakeThickSolid();
# 126 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
BRepOffsetAPI_MakeThickSolid(const TopoDS_Shape& S,const TopTools_ListOfShape& ClosingFaces,const Standard_Real Offset,const Standard_Real Tol,const BRepOffset_Mode Mode = BRepOffset_Skin,const Standard_Boolean Intersection = (Standard_Boolean) 0,const Standard_Boolean SelfInter = (Standard_Boolean) 0,const GeomAbs_JoinType Join = GeomAbs_Arc);

virtual void Build() ;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;

protected:
# 149 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
private:
# 159 “/usr/include/opencascade/BRepOffsetAPI_MakeThickSolid.hxx”
};
# 15 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx” 1
# 26 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
# 1 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx” 1
# 26 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_BaseSequence.hxx” 1
# 34 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
class Standard_NoSuchObject;
class Standard_OutOfRange;
# 53 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
class TCollection_BaseSequence {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

Standard_Boolean IsEmpty() const;

Standard_Integer Length() const;

void Reverse() ;
# 93 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
void Exchange(const Standard_Integer I,const Standard_Integer J) ;

protected:

TCollection_BaseSequence();

void Clear(const Standard_Address DelNode) ;

void PAppend(const Standard_Address Node) ;
# 122 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
void PAppend(TCollection_BaseSequence& S) ;

void PPrepend(const Standard_Address Node) ;
# 134 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
void PPrepend(TCollection_BaseSequence& S) ;

void PInsertAfter(const Standard_Integer Index,const Standard_Address Node) ;
# 148 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
void PInsertAfter(const Standard_Integer Index,TCollection_BaseSequence& S) ;
# 158 “/usr/include/opencascade/TCollection_BaseSequence.hxx”
void PSplit(const Standard_Integer Index,TCollection_BaseSequence& Sub) ;

void Remove(const Standard_Integer Index,const Standard_Address DelNode) ;

void Remove(const Standard_Integer FromIndex,const Standard_Integer ToIndex,const Standard_Address DelNode) ;

Standard_Address Find(const Standard_Integer Index) const;

Standard_Address FirstItem;
Standard_Address LastItem;
Standard_Address CurrentItem;
Standard_Integer CurrentIndex;
Standard_Integer Size;

private:

TCollection_BaseSequence(const TCollection_BaseSequence& Other);

void Nullify() ;

};

# 1 “/usr/include/opencascade/TCollection_BaseSequence.lxx” 1

inline Standard_Boolean TCollection_BaseSequence::IsEmpty() const
{
return Size == 0;
}

inline Standard_Integer TCollection_BaseSequence::Length() const
{
return Size;

}
# 202 “/usr/include/opencascade/TCollection_BaseSequence.hxx” 2
# 27 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopTools_SequenceNodeOfSequenceOfShape.hxx” 1
# 33 “/usr/include/opencascade/Handle_TopTools_SequenceNodeOfSequenceOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TCollection_SeqNode.hxx” 1
# 36 “/usr/include/opencascade/Handle_TCollection_SeqNode.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TCollection_SeqNode;
Handle_Standard_Type& TCollection_SeqNode_Type_();

class Handle_TCollection_SeqNode : public Handle_MMgt_TShared {
public:
Handle_TCollection_SeqNode():Handle_MMgt_TShared() {}
Handle_TCollection_SeqNode(const Handle_TCollection_SeqNode& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TCollection_SeqNode(const TCollection_SeqNode* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TCollection_SeqNode& operator=(const Handle_TCollection_SeqNode& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TCollection_SeqNode& operator=(const TCollection_SeqNode* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TCollection_SeqNode* operator->() const
{
return (TCollection_SeqNode *)ControlAccess();
}

static const Handle_TCollection_SeqNode DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_TopTools_SequenceNodeOfSequenceOfShape.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_SeqNode;
class TopTools_SequenceNodeOfSequenceOfShape;
Handle_Standard_Type& TopTools_SequenceNodeOfSequenceOfShape_Type_();

class Handle_TopTools_SequenceNodeOfSequenceOfShape : public Handle_TCollection_SeqNode {
public:
Handle_TopTools_SequenceNodeOfSequenceOfShape():Handle_TCollection_SeqNode() {}
Handle_TopTools_SequenceNodeOfSequenceOfShape(const Handle_TopTools_SequenceNodeOfSequenceOfShape& aHandle) : Handle_TCollection_SeqNode(aHandle)
{
}

Handle_TopTools_SequenceNodeOfSequenceOfShape(const TopTools_SequenceNodeOfSequenceOfShape* anItem) : Handle_TCollection_SeqNode((TCollection_SeqNode *)anItem)
{
}

Handle_TopTools_SequenceNodeOfSequenceOfShape& operator=(const Handle_TopTools_SequenceNodeOfSequenceOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_SequenceNodeOfSequenceOfShape& operator=(const TopTools_SequenceNodeOfSequenceOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_SequenceNodeOfSequenceOfShape* operator->() const
{
return (TopTools_SequenceNodeOfSequenceOfShape *)ControlAccess();
}

static const Handle_TopTools_SequenceNodeOfSequenceOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx” 2

class Standard_NoSuchObject;
class Standard_OutOfRange;
class TopoDS_Shape;
class TopTools_SequenceNodeOfSequenceOfShape;
# 48 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx”
class TopTools_SequenceOfShape : public TCollection_BaseSequence {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_SequenceOfShape();

void Clear() ;
~TopTools_SequenceOfShape()
{
Clear();
}

const TopTools_SequenceOfShape& Assign(const TopTools_SequenceOfShape& Other) ;
const TopTools_SequenceOfShape& operator =(const TopTools_SequenceOfShape& Other)
{
return Assign(Other);
}

void Append(const TopoDS_Shape& T) ;

void Append(TopTools_SequenceOfShape& S) ;

void Prepend(const TopoDS_Shape& T) ;

void Prepend(TopTools_SequenceOfShape& S) ;

void InsertBefore(const Standard_Integer Index,const TopoDS_Shape& T) ;

void InsertBefore(const Standard_Integer Index,TopTools_SequenceOfShape& S) ;

void InsertAfter(const Standard_Integer Index,const TopoDS_Shape& T) ;

void InsertAfter(const Standard_Integer Index,TopTools_SequenceOfShape& S) ;

const TopoDS_Shape& First() const;

const TopoDS_Shape& Last() const;

void Split(const Standard_Integer Index,TopTools_SequenceOfShape& Sub) ;

const TopoDS_Shape& Value(const Standard_Integer Index) const;
const TopoDS_Shape& operator()(const Standard_Integer Index) const
{
return Value(Index);
}

void SetValue(const Standard_Integer Index,const TopoDS_Shape& I) ;

TopoDS_Shape& ChangeValue(const Standard_Integer Index) ;
TopoDS_Shape& operator()(const Standard_Integer Index)
{
return ChangeValue(Index);
}

void Remove(const Standard_Integer Index) ;

void Remove(const Standard_Integer FromIndex,const Standard_Integer ToIndex) ;

protected:
# 151 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx”
private:

TopTools_SequenceOfShape(const TopTools_SequenceOfShape& Other);

};
# 175 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_Sequence.lxx” 1
# 11 “/usr/include/opencascade/TCollection_Sequence.lxx”
inline TopTools_SequenceOfShape::TopTools_SequenceOfShape()
{
}

inline void TopTools_SequenceOfShape::Append (TopTools_SequenceOfShape& S)
{
if (FirstItem == S.FirstItem) Assign(S);
PAppend (S);
}

inline void TopTools_SequenceOfShape::Prepend (TopTools_SequenceOfShape& S)
{
if (FirstItem == S.FirstItem) Assign(S);
PPrepend (S);
}

inline void TopTools_SequenceOfShape::InsertBefore (const Standard_Integer Index,
const TopoDS_Shape& I)
{
InsertAfter(Index-1,I);
}

inline void TopTools_SequenceOfShape::InsertBefore (const Standard_Integer Index,
TopTools_SequenceOfShape& S)
{
InsertAfter(Index-1,S);
}

inline void TopTools_SequenceOfShape::InsertAfter (const Standard_Integer Index,
TopTools_SequenceOfShape& S)
{
PInsertAfter(Index,S);
}

inline void TopTools_SequenceOfShape::Split (const Standard_Integer Index,
TopTools_SequenceOfShape& S)
{
S.Clear();
PSplit(Index,S);
}
# 176 “/usr/include/opencascade/TopTools_SequenceOfShape.hxx” 2
# 27 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx” 2
# 35 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
# 1 “/usr/include/opencascade/TopoDS_Face.hxx” 1
# 44 “/usr/include/opencascade/TopoDS_Face.hxx”
class TopoDS_Face : public TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Face();

protected:
# 80 “/usr/include/opencascade/TopoDS_Face.hxx”
private:
# 90 “/usr/include/opencascade/TopoDS_Face.hxx”
};
# 36 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx” 2

class TopoDS_Wire;
class TopoDS_Vertex;
class TopoDS_Shape;
# 59 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
class BRepOffsetAPI_ThruSections : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 90 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
BRepOffsetAPI_ThruSections(const Standard_Boolean isSolid = (Standard_Boolean) 0,const Standard_Boolean ruled = (Standard_Boolean) 0,const Standard_Real pres3d = 1.0e-06);
# 104 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
void Init(const Standard_Boolean isSolid = (Standard_Boolean) 0,const Standard_Boolean ruled = (Standard_Boolean) 0,const Standard_Real pres3d = 1.0e-06) ;

void AddWire(const TopoDS_Wire& wire) ;

void AddVertex(const TopoDS_Vertex& aVertex) ;

void CheckCompatibility(const Standard_Boolean check = (Standard_Boolean) 1) ;

virtual void Build() ;

const TopoDS_Shape& FirstShape() const;

const TopoDS_Shape& LastShape() const;

TopoDS_Shape GeneratedFace(const TopoDS_Shape& Edge) const;

protected:
# 151 “/usr/include/opencascade/BRepOffsetAPI_ThruSections.hxx”
private:

void CreateRuled() ;

void CreateSmoothed() ;

TopTools_SequenceOfShape myWires;
Standard_Boolean myIsSolid;
Standard_Boolean myIsRuled;
Standard_Boolean myWCheck;
Standard_Real myPres3d;
TopoDS_Face myFirst;
TopoDS_Face myLast;
TopTools_DataMapOfShapeShape myGenerated;

};
# 16 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepPrimAPI_MakeCylinder.hxx” 1
# 26 “/usr/include/opencascade/BRepPrimAPI_MakeCylinder.hxx”
# 1 “/usr/include/opencascade/BRepPrim_Cylinder.hxx” 1
# 29 “/usr/include/opencascade/BRepPrim_Cylinder.hxx”
# 1 “/usr/include/opencascade/BRepPrim_Revolution.hxx” 1
# 32 “/usr/include/opencascade/BRepPrim_Revolution.hxx”
# 1 “/usr/include/opencascade/BRepPrim_OneAxis.hxx” 1
# 19 “/usr/include/opencascade/BRepPrim_OneAxis.hxx”
# 1 “/usr/include/opencascade/BRepPrim_Builder.hxx” 1
# 26 “/usr/include/opencascade/BRepPrim_Builder.hxx”
# 1 “/usr/include/opencascade/BRep_Builder.hxx” 1
# 26 “/usr/include/opencascade/BRep_Builder.hxx”
# 1 “/usr/include/opencascade/TopoDS_Builder3D.hxx” 1
# 26 “/usr/include/opencascade/TopoDS_Builder3D.hxx”
# 1 “/usr/include/opencascade/TopoDS_Builder.hxx” 1
# 28 “/usr/include/opencascade/TopoDS_Builder.hxx”
class Standard_NullObject;
class TopoDS_FrozenShape;
class TopoDS_UnCompatibleShapes;
class TopoDS_Shape;
class TopoDS_TShape;
class TopoDS_Wire;
class TopoDS_Compound;
# 58 “/usr/include/opencascade/TopoDS_Builder.hxx”
class TopoDS_Builder {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

void MakeWire(TopoDS_Wire& W) const;

void MakeCompound(TopoDS_Compound& C) const;

void Add(TopoDS_Shape& S,const TopoDS_Shape& C) const;

void Remove(TopoDS_Shape& S,const TopoDS_Shape& C) const;

protected:

TopoDS_Builder();

void MakeShape(TopoDS_Shape& S,const Handle_TopoDS_TShape& T) const;

private:
# 125 “/usr/include/opencascade/TopoDS_Builder.hxx”
};
# 27 “/usr/include/opencascade/TopoDS_Builder3D.hxx” 2

class Standard_NullObject;
class TopoDS_Shell;
class TopoDS_Solid;
class TopoDS_CompSolid;
# 45 “/usr/include/opencascade/TopoDS_Builder3D.hxx”
class TopoDS_Builder3D : public TopoDS_Builder {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

void MakeShell(TopoDS_Shell& S) const;

void MakeSolid(TopoDS_Solid& S) const;

void MakeCompSolid(TopoDS_CompSolid& C) const;

protected:

TopoDS_Builder3D();

private:
# 100 “/usr/include/opencascade/TopoDS_Builder3D.hxx”
};
# 27 “/usr/include/opencascade/BRep_Builder.hxx” 2
# 58 “/usr/include/opencascade/BRep_Builder.hxx”
class Standard_NullObject;
class Standard_DomainError;
class TopoDS_Face;
class Geom_Surface;
class TopLoc_Location;
class Poly_Triangulation;
class TopoDS_Edge;
class Geom_Curve;
class Poly_Polygon3D;
class Poly_PolygonOnTriangulation;
class Geom2d_Curve;
class gp_Pnt2d;
class Poly_Polygon2D;
class TopoDS_Vertex;
class gp_Pnt;
# 97 “/usr/include/opencascade/BRep_Builder.hxx”
class BRep_Builder : public TopoDS_Builder3D {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRep_Builder();

void MakeFace(TopoDS_Face& F) const;

void MakeFace(TopoDS_Face& F,const Handle_Geom_Surface& S,const Standard_Real Tol) const;

void MakeFace(TopoDS_Face& F,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol) const;

void MakeFace(TopoDS_Face& F,const Handle_Poly_Triangulation& T) const;

void UpdateFace(const TopoDS_Face& F,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol) const;

void UpdateFace(const TopoDS_Face& F,const Handle_Poly_Triangulation& T) const;

void UpdateFace(const TopoDS_Face& F,const Standard_Real Tol) const;

void NaturalRestriction(const TopoDS_Face& F,const Standard_Boolean N) const;

void MakeEdge(TopoDS_Edge& E) const;

void MakeEdge(TopoDS_Edge& E,const Handle_Geom_Curve& C,const Standard_Real Tol) const;

void MakeEdge(TopoDS_Edge& E,const Handle_Geom_Curve& C,const TopLoc_Location& L,const Standard_Real Tol) const;

void MakeEdge(TopoDS_Edge& E,const Handle_Poly_Polygon3D& P) const;

void MakeEdge(TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N,const Handle_Poly_Triangulation& T) const;

void MakeEdge(TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N,const Handle_Poly_Triangulation& T,const TopLoc_Location& L) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom_Curve& C,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom_Curve& C,const TopLoc_Location& L,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C,const TopoDS_Face& F,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C1,const Handle_Geom2d_Curve& C2,const TopoDS_Face& F,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol,const gp_Pnt2d& Pf,const gp_Pnt2d& Pl) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C1,const Handle_Geom2d_Curve& C2,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Geom2d_Curve& C1,const Handle_Geom2d_Curve& C2,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol,const gp_Pnt2d& Pf,const gp_Pnt2d& Pl) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon3D& P) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon3D& P,const TopLoc_Location& L) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N,const Handle_Poly_Triangulation& T) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N,const Handle_Poly_Triangulation& T,const TopLoc_Location& L) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N1,const Handle_Poly_PolygonOnTriangulation& N2,const Handle_Poly_Triangulation& T,const TopLoc_Location& L) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_PolygonOnTriangulation& N1,const Handle_Poly_PolygonOnTriangulation& N2,const Handle_Poly_Triangulation& T) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon2D& P,const TopoDS_Face& S) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon2D& P,const Handle_Geom_Surface& S,const TopLoc_Location& T) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon2D& P1,const Handle_Poly_Polygon2D& P2,const TopoDS_Face& S) const;

void UpdateEdge(const TopoDS_Edge& E,const Handle_Poly_Polygon2D& P1,const Handle_Poly_Polygon2D& P2,const Handle_Geom_Surface& S,const TopLoc_Location& L) const;

void UpdateEdge(const TopoDS_Edge& E,const Standard_Real Tol) const;

void Continuity(const TopoDS_Edge& E,const TopoDS_Face& F1,const TopoDS_Face& F2,const GeomAbs_Shape C) const;

void Continuity(const TopoDS_Edge& E,const Handle_Geom_Surface& S1,const Handle_Geom_Surface& S2,const TopLoc_Location& L1,const TopLoc_Location& L2,const GeomAbs_Shape C) const;

void SameParameter(const TopoDS_Edge& E,const Standard_Boolean S) const;

void SameRange(const TopoDS_Edge& E,const Standard_Boolean S) const;

void Degenerated(const TopoDS_Edge& E,const Standard_Boolean D) const;

void Range(const TopoDS_Edge& E,const Standard_Real First,const Standard_Real Last,const Standard_Boolean Only3d = (Standard_Boolean) 0) const;

void Range(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real First,const Standard_Real Last) const;

void Range(const TopoDS_Edge& E,const TopoDS_Face& F,const Standard_Real First,const Standard_Real Last) const;

void Transfert(const TopoDS_Edge& Ein,const TopoDS_Edge& Eout) const;

void MakeVertex(TopoDS_Vertex& V) const;

void MakeVertex(TopoDS_Vertex& V,const gp_Pnt& P,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& V,const gp_Pnt& P,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& V,const Standard_Real P,const TopoDS_Edge& E,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& V,const Standard_Real P,const TopoDS_Edge& E,const TopoDS_Face& F,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& V,const Standard_Real P,const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& Ve,const Standard_Real U,const Standard_Real V,const TopoDS_Face& F,const Standard_Real Tol) const;

void UpdateVertex(const TopoDS_Vertex& V,const Standard_Real Tol) const;

void Transfert(const TopoDS_Edge& Ein,const TopoDS_Edge& Eout,const TopoDS_Vertex& Vin,const TopoDS_Vertex& Vout) const;

protected:
# 340 “/usr/include/opencascade/BRep_Builder.hxx”
private:
# 350 “/usr/include/opencascade/BRep_Builder.hxx”
};
# 27 “/usr/include/opencascade/BRepPrim_Builder.hxx” 2

class BRep_Builder;
class TopoDS_Shell;
class TopoDS_Face;
class gp_Pln;
class TopoDS_Wire;
class TopoDS_Edge;
class gp_Lin;
class gp_Circ;
class gp_Lin2d;
class gp_Circ2d;
class TopoDS_Vertex;
class gp_Pnt;
# 56 “/usr/include/opencascade/BRepPrim_Builder.hxx”
class BRepPrim_Builder {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepPrim_Builder();

BRepPrim_Builder(const BRep_Builder& B);

const BRep_Builder& Builder() const;

void MakeShell(TopoDS_Shell& S) const;

void MakeFace(TopoDS_Face& F,const gp_Pln& P) const;

void MakeWire(TopoDS_Wire& W) const;

void MakeDegeneratedEdge(TopoDS_Edge& E) const;

void MakeEdge(TopoDS_Edge& E,const gp_Lin& L) const;

void MakeEdge(TopoDS_Edge& E,const gp_Circ& C) const;

void SetPCurve(TopoDS_Edge& E,const TopoDS_Face& F,const gp_Lin2d& L) const;

void SetPCurve(TopoDS_Edge& E,const TopoDS_Face& F,const gp_Lin2d& L1,const gp_Lin2d& L2) const;

void SetPCurve(TopoDS_Edge& E,const TopoDS_Face& F,const gp_Circ2d& C) const;

void MakeVertex(TopoDS_Vertex& V,const gp_Pnt& P) const;

void ReverseFace(TopoDS_Face& F) const;

void AddEdgeVertex(TopoDS_Edge& E,const TopoDS_Vertex& V,const Standard_Real P,const Standard_Boolean direct) const;

void AddEdgeVertex(TopoDS_Edge& E,const TopoDS_Vertex& V,const Standard_Real P1,const Standard_Real P2) const;

void SetParameters(TopoDS_Edge& E,const TopoDS_Vertex& V,const Standard_Real P1,const Standard_Real P2) const;

void AddWireEdge(TopoDS_Wire& W,const TopoDS_Edge& E,const Standard_Boolean direct) const;

void AddFaceWire(TopoDS_Face& F,const TopoDS_Wire& W) const;

void AddShellFace(TopoDS_Shell& Sh,const TopoDS_Face& F) const;

void CompleteEdge(TopoDS_Edge& E) const;

void CompleteWire(TopoDS_Wire& W) const;

void CompleteFace(TopoDS_Face& F) const;

void CompleteShell(TopoDS_Shell& S) const;

protected:
# 180 “/usr/include/opencascade/BRepPrim_Builder.hxx”
private:

BRep_Builder myBuilder;

};

# 1 “/usr/include/opencascade/BRepPrim_Builder.lxx” 1
# 12 “/usr/include/opencascade/BRepPrim_Builder.lxx”
inline const BRep_Builder& BRepPrim_Builder::Builder() const
{
return myBuilder;
}
# 195 “/usr/include/opencascade/BRepPrim_Builder.hxx” 2
# 20 “/usr/include/opencascade/BRepPrim_OneAxis.hxx” 2

# 1 “/usr/include/opencascade/gp_Ax2.hxx” 1
# 26 “/usr/include/opencascade/gp_Ax2.hxx”
# 1 “/usr/include/opencascade/gp_Ax1.hxx” 1
# 43 “/usr/include/opencascade/gp_Ax1.hxx”
class gp_Pnt;
class gp_Dir;
class gp_Ax2;
class gp_Trsf;
class gp_Vec;
# 57 “/usr/include/opencascade/gp_Ax1.hxx”
Handle_Standard_Type& gp_Ax1_Type_();
# 71 “/usr/include/opencascade/gp_Ax1.hxx”
class gp_Ax1 {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Ax1();

gp_Ax1(const gp_Pnt& P,const gp_Dir& V);

void SetDirection(const gp_Dir& V) ;

void SetLocation(const gp_Pnt& P) ;

const gp_Dir& Direction() const;

const gp_Pnt& Location() const;
# 111 “/usr/include/opencascade/gp_Ax1.hxx”
Standard_Boolean IsCoaxial(const gp_Ax1& Other,const Standard_Real AngularTolerance,const Standard_Real LinearTolerance) const;

Standard_Boolean IsNormal(const gp_Ax1& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Ax1& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Ax1& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Ax1& Other) const;

void Reverse() ;

gp_Ax1 Reversed() const;

void Mirror(const gp_Pnt& P) ;

gp_Ax1 Mirrored(const gp_Pnt& P) const;

void Mirror(const gp_Ax1& A1) ;

gp_Ax1 Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Ax1 Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Ax1 Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const gp_Pnt& P,const Standard_Real S) ;

gp_Ax1 Scaled(const gp_Pnt& P,const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Ax1 Transformed(const gp_Trsf& T) const;

void Translate(const gp_Vec& V) ;

gp_Ax1 Translated(const gp_Vec& V) const;

void Translate(const gp_Pnt& P1,const gp_Pnt& P2) ;

gp_Ax1 Translated(const gp_Pnt& P1,const gp_Pnt& P2) const;
const gp_Pnt& _CSFDB_Getgp_Ax1loc() const { return loc; }
const gp_Dir& _CSFDB_Getgp_Ax1vdir() const { return vdir; }

friend Handle_Standard_Type& gp_Ax1_Type_();

protected:
# 240 “/usr/include/opencascade/gp_Ax1.hxx”
private:

gp_Pnt loc;
gp_Dir vdir;

};

# 1 “/usr/include/opencascade/gp_Ax1.lxx” 1

inline gp_Ax1::gp_Ax1()
{ }

inline gp_Ax1::gp_Ax1 (const gp_Pnt& P,
const gp_Dir& V) : loc(P), vdir(V)
{ }

inline void gp_Ax1::SetDirection (const gp_Dir& V)
{ vdir = V; }

inline void gp_Ax1::SetLocation (const gp_Pnt& P)
{ loc = P; }

inline const gp_Dir& gp_Ax1::Direction () const
{ return vdir; }

inline const gp_Pnt& gp_Ax1::Location () const
{ return loc; }

inline Standard_Boolean gp_Ax1::IsNormal
(const gp_Ax1& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsNormal(Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax1::IsOpposite
(const gp_Ax1& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsOpposite(Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax1::IsParallel
(const gp_Ax1& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsParallel(Other.vdir, AngularTolerance); }

inline Standard_Real gp_Ax1::Angle (const gp_Ax1& Other) const
{ return vdir.Angle (Other.vdir); }

inline void gp_Ax1::Reverse ()
{ vdir.Reverse(); }

inline gp_Ax1 gp_Ax1::Reversed () const
{
gp_Dir D = vdir.Reversed();
return gp_Ax1(loc, D);
}

inline void gp_Ax1::Rotate (const gp_Ax1& A1, const Standard_Real Ang)
{
loc.Rotate(A1, Ang);
vdir.Rotate(A1 , Ang);
}

inline gp_Ax1 gp_Ax1::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Ax1 A = *this;
A.Rotate (A1, Ang);
return A;
}

inline void gp_Ax1::Scale (const gp_Pnt& P,
const Standard_Real S)
{
loc.Scale (P, S);
if (S < 0.0) vdir.Reverse();
}

inline gp_Ax1 gp_Ax1::Scaled (const gp_Pnt& P,
const Standard_Real S) const
{
gp_Ax1 A1 = *this;
A1.Scale (P, S);
return A1;
}

inline void gp_Ax1::Transform (const gp_Trsf& T)
{
loc.Transform(T);
vdir.Transform(T);
}

inline gp_Ax1 gp_Ax1::Transformed (const gp_Trsf& T) const
{
gp_Ax1 A1 = *this;
A1.Transform (T);
return A1;
}

inline void gp_Ax1::Translate (const gp_Vec& V)
{ loc.Translate (V); }

inline gp_Ax1 gp_Ax1::Translated (const gp_Vec& V) const
{
gp_Ax1 A1 = *this;
(A1.loc).Translate (V);
return A1;
}

inline void gp_Ax1::Translate (const gp_Pnt& P1,
const gp_Pnt& P2)
{
loc.Translate (P1, P2);
}

inline gp_Ax1 gp_Ax1::Translated (const gp_Pnt& P1,
const gp_Pnt& P2) const
{
gp_Ax1 A1 = *this;
(A1.loc).Translate (P1, P2);
return A1;
}
# 256 “/usr/include/opencascade/gp_Ax1.hxx” 2
# 27 “/usr/include/opencascade/gp_Ax2.hxx” 2
# 43 “/usr/include/opencascade/gp_Ax2.hxx”
class Standard_ConstructionError;
class gp_Pnt;
class gp_Dir;
class gp_Ax1;
class gp_Trsf;
class gp_Vec;
# 58 “/usr/include/opencascade/gp_Ax2.hxx”
Handle_Standard_Type& gp_Ax2_Type_();
# 89 “/usr/include/opencascade/gp_Ax2.hxx”
class gp_Ax2 {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Ax2();

gp_Ax2(const gp_Pnt& P,const gp_Dir& N,const gp_Dir& Vx);

gp_Ax2(const gp_Pnt& P,const gp_Dir& V);
# 132 “/usr/include/opencascade/gp_Ax2.hxx”
void SetAxis(const gp_Ax1& A1) ;
# 142 “/usr/include/opencascade/gp_Ax2.hxx”
void SetDirection(const gp_Dir& V) ;

void SetLocation(const gp_Pnt& P) ;
# 156 “/usr/include/opencascade/gp_Ax2.hxx”
void SetXDirection(const gp_Dir& Vx) ;
# 167 “/usr/include/opencascade/gp_Ax2.hxx”
void SetYDirection(const gp_Dir& Vy) ;

Standard_Real Angle(const gp_Ax2& Other) const;

const gp_Ax1& Axis() const;

const gp_Dir& Direction() const;

const gp_Pnt& Location() const;

const gp_Dir& XDirection() const;

const gp_Dir& YDirection() const;

Standard_Boolean IsCoplanar(const gp_Ax2& Other,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;

Standard_Boolean IsCoplanar(const gp_Ax1& A1,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;
# 217 “/usr/include/opencascade/gp_Ax2.hxx”
void Mirror(const gp_Pnt& P) ;
# 235 “/usr/include/opencascade/gp_Ax2.hxx”
gp_Ax2 Mirrored(const gp_Pnt& P) const;
# 253 “/usr/include/opencascade/gp_Ax2.hxx”
void Mirror(const gp_Ax1& A1) ;
# 271 “/usr/include/opencascade/gp_Ax2.hxx”
gp_Ax2 Mirrored(const gp_Ax1& A1) const;
# 290 “/usr/include/opencascade/gp_Ax2.hxx”
void Mirror(const gp_Ax2& A2) ;
# 309 “/usr/include/opencascade/gp_Ax2.hxx”
gp_Ax2 Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Ax2 Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const gp_Pnt& P,const Standard_Real S) ;
# 327 “/usr/include/opencascade/gp_Ax2.hxx”
gp_Ax2 Scaled(const gp_Pnt& P,const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Ax2 Transformed(const gp_Trsf& T) const;

void Translate(const gp_Vec& V) ;

gp_Ax2 Translated(const gp_Vec& V) const;

void Translate(const gp_Pnt& P1,const gp_Pnt& P2) ;

gp_Ax2 Translated(const gp_Pnt& P1,const gp_Pnt& P2) const;
const gp_Ax1& _CSFDB_Getgp_Ax2axis() const { return axis; }
const gp_Dir& _CSFDB_Getgp_Ax2vydir() const { return vydir; }
const gp_Dir& _CSFDB_Getgp_Ax2vxdir() const { return vxdir; }

friend Handle_Standard_Type& gp_Ax2_Type_();

protected:
# 370 “/usr/include/opencascade/gp_Ax2.hxx”
private:

gp_Ax1 axis;
gp_Dir vydir;
gp_Dir vxdir;

};

# 1 “/usr/include/opencascade/gp_Ax2.lxx” 1

# 1 “/usr/include/opencascade/Precision.hxx” 1
# 112 “/usr/include/opencascade/Precision.hxx”
class Precision {

public:

void* operator new(size_t,void* anAddress)
{

Posted in Uncategorized | Leave a comment

Part 2)Trying to get MakeBottle.cxx to compile.

Continuing from part 1)

Ok…. Obviously something is not right here.
I’m thinking its time to get back to a baseline and try this again….  There’s a install version of opencascade there available for opennovation that/synaptic  I thought I give it a try.
First things first.  I need to figure out how to unistall opencascade.

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/uninstall/Linux$ sudo java -jar uninstall.jar

For some reason not everything got deleted.  On some file the rm wouldnt work.  I need to work that out later.
I ran across this nice little link discussing file permission:http://www.tuxfiles.org/linuxhelp/filepermissions.html
This got me confused time to call in the calvary(http://ubuntuforums.org/showthread.php?p=5534934#post5534934)

Doh… very obvious…
I left the OCC documentation intact… We’ll see how that works.
Alright… I’m going to try loading open cascade from a different direction. Instructions as per:
http://www.opennovation.org/ubuntu/

Wow… So far so good.
I tried firing up the DRAWEXE test program.  You should find documention on file:///usr/share/doc/opencascade-doc/doc/index.htm#Welcome_to_Open_CASCADE_Technology.htm

I got a irritating error message when I fired up pload ALL
“Cannot load Debug Browser library. DFBrowser command is not attached”
That error didn’t seem to mess up the example given in the tutorial.

In the non-synaptic version of opencascade there is some source called MakeBottle.cxx.  It doesn’t see to be include in the debian download.  Luckily I had copied it to a separate directory.

I tried to compile the source and here are the error messages from the start:

jonas@Ubuntu4:/$ locate MakeBottle.cxx
/home/jonas/OCC_bottle/MakeBottle.cxx
jonas@Ubuntu4:/$ cd /home/jonas/OCC_bottle
jonas@Ubuntu4:~/OCC_bottle$ g++ -I /usr/include/opencascade MakeBottle.cxx
In file included from /usr/include/opencascade/Standard_Integer.hxx:9,
from /usr/include/opencascade/Standard_Address.hxx:21,
from /usr/include/opencascade/Standard.hxx:28,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:29,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_values.h:35:2: error: #error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
In file included from /usr/include/opencascade/Standard_OStream.hxx:7,
from /usr/include/opencascade/Standard.hxx:40,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:29,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Stream.hxx:19:2: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /usr/include/opencascade/Standard_OutOfRange.hxx:33,
from /usr/include/opencascade/gp_Mat.lxx:4,
from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/Standard_SStream.hxx:23:4: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /usr/include/opencascade/Standard_Address.hxx:21,
from /usr/include/opencascade/Standard.hxx:28,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:29,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Integer.hxx: In function ‘Standard_Integer IntegerFirst()’:
/usr/include/opencascade/Standard_Integer.hxx:129: error: ‘INT_MIN’ was not declared in this scope
/usr/include/opencascade/Standard_Integer.hxx: In function ‘Standard_Integer IntegerLast()’:
/usr/include/opencascade/Standard_Integer.hxx:135: error: ‘INT_MAX’ was not declared in this scope
/usr/include/opencascade/Standard_Integer.hxx: In function ‘Standard_Integer IntegerSize()’:
/usr/include/opencascade/Standard_Integer.hxx:141: error: ‘CHAR_BIT’ was not declared in this scope
In file included from /usr/include/opencascade/Standard_PrimitiveTypes.hxx:23,
from /usr/include/opencascade/Handle_Standard_Transient.hxx:10,
from /usr/include/opencascade/Handle_MMgt_TShared.hxx:33,
from /usr/include/opencascade/Handle_Geom_Geometry.hxx:33,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:33,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Real.hxx: In function ‘Standard_Integer RealSize()’:
/usr/include/opencascade/Standard_Real.hxx:162: error: ‘CHAR_BIT’ was not declared in this scope
In file included from /usr/include/opencascade/Standard_PrimitiveTypes.hxx:41,
from /usr/include/opencascade/Handle_Standard_Transient.hxx:10,
from /usr/include/opencascade/Handle_MMgt_TShared.hxx:33,
from /usr/include/opencascade/Handle_Geom_Geometry.hxx:33,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:33,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Storable.hxx: At global scope:
/usr/include/opencascade/Standard_Storable.hxx:101: error: ‘ostream’ has not been declared
/usr/include/opencascade/Standard_Storable.hxx:146: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Handle_Standard_Transient.hxx:13,
from /usr/include/opencascade/Handle_MMgt_TShared.hxx:33,
from /usr/include/opencascade/Handle_Geom_Geometry.hxx:33,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:33,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Standard_Transient_proto.hxx:69: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Handle_MMgt_TShared.hxx:33,
from /usr/include/opencascade/Handle_Geom_Geometry.hxx:33,
from /usr/include/opencascade/Handle_Geom_Surface.hxx:33,
from /usr/include/opencascade/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/usr/include/opencascade/Handle_Standard_Transient.hxx:182: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/TopoDS_Shape.hxx:29,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/TopLoc_Location.hxx:178: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/TopoDS_Shape.hxx:29,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/TopLoc_Location.hxx:218: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Standard_Transient.hxx:14,
from /usr/include/opencascade/MMgt_TShared.hxx:34,
from /usr/include/opencascade/TopoDS_TShape.hxx:40,
from /usr/include/opencascade/TopoDS_Shape.lxx:7,
from /usr/include/opencascade/TopoDS_Shape.hxx:277,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/Standard_Type.hxx:141: error: ‘ostream’ has not been declared
/usr/include/opencascade/Standard_Type.hxx:150: error: ‘ostream’ has not been declared
/usr/include/opencascade/Standard_Type.hxx:151: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Standard_Type.hxx:201,
from /usr/include/opencascade/Standard_Transient.hxx:14,
from /usr/include/opencascade/MMgt_TShared.hxx:34,
from /usr/include/opencascade/TopoDS_TShape.hxx:40,
from /usr/include/opencascade/TopoDS_Shape.lxx:7,
from /usr/include/opencascade/TopoDS_Shape.hxx:277,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/Standard_Type.lxx:13: error: expected constructor, destructor, or type conversion before ‘&’ token
In file included from /usr/include/opencascade/Standard_Transient.hxx:14,
from /usr/include/opencascade/MMgt_TShared.hxx:34,
from /usr/include/opencascade/TopoDS_TShape.hxx:40,
from /usr/include/opencascade/TopoDS_Shape.lxx:7,
from /usr/include/opencascade/TopoDS_Shape.hxx:277,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/Standard_Type.hxx:211: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/TopoDS_Shape.lxx:8,
from /usr/include/opencascade/TopoDS_Shape.hxx:277,
from /usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx:26,
from /usr/include/opencascade/BRepAlgoAPI_Fuse.hxx:26,
from MakeBottle.cxx:3:
/usr/include/opencascade/TopAbs.hxx:118: error: ISO C++ forbids declaration of ‘ostream’ with no type
/usr/include/opencascade/TopAbs.hxx:118: error: expected ‘;’ before ‘&’ token
/usr/include/opencascade/TopAbs.hxx:123: error: ISO C++ forbids declaration of ‘ostream’ with no type
/usr/include/opencascade/TopAbs.hxx:123: error: expected ‘;’ before ‘&’ token
/usr/include/opencascade/TopAbs.hxx:128: error: ISO C++ forbids declaration of ‘ostream’ with no type
/usr/include/opencascade/TopAbs.hxx:128: error: expected ‘;’ before ‘&’ token
In file included from /usr/include/opencascade/TopTools_MapOfShape.hxx:26,
from /usr/include/opencascade/BRepLib_MakeWire.hxx:35,
from /usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx:26,
from MakeBottle.cxx:7:
/usr/include/opencascade/TCollection_BasicMap.hxx:134: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Standard_OutOfRange.hxx:33,
from /usr/include/opencascade/gp_Mat.lxx:4,
from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/Standard_SStream.hxx:58: error: expected class-name before ‘{’ token
/usr/include/opencascade/Standard_SStream.hxx:62: error: expected )' before ‘&’ token
In file included from /usr/include/opencascade/Standard_DomainError.hxx:38,
from /usr/include/opencascade/Standard_RangeError.hxx:38,
from /usr/include/opencascade/Standard_OutOfRange.hxx:38,
from /usr/include/opencascade/gp_Mat.lxx:4,
from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/Standard_Failure.hxx:83: error: ‘ostream’ has not been declared
/usr/include/opencascade/Standard_Failure.hxx:84: error: ‘ostream’ has not been declared
In file included from /usr/include/opencascade/Standard_Failure.hxx:168,
from /usr/include/opencascade/Standard_DomainError.hxx:38,
from /usr/include/opencascade/Standard_RangeError.hxx:38,
from /usr/include/opencascade/Standard_OutOfRange.hxx:38,
from /usr/include/opencascade/gp_Mat.lxx:4,
from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/Standard_Failure.lxx:9: error: expected initializer before ‘&’ token
In file included from /usr/include/opencascade/gp_Mat.hxx:326,
from /usr/include/opencascade/gp_Trsf.hxx:32,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Mat.lxx: In member function ‘void gp_Mat::SetValue(Standard_Integer, Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Mat.lxx:98: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘const Standard_Real& gp_Mat::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Mat.lxx:115: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘Standard_Real& gp_Mat::ChangeValue(Standard_Integer, Standard_Integer)’:
/usr/include/opencascade/gp_Mat.lxx:123: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘void gp_Mat::Divide(Standard_Real)’:
/usr/include/opencascade/gp_Mat.lxx:173: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat.lxx: In member function ‘gp_Mat gp_Mat::Divided(Standard_Real) const’:
/usr/include/opencascade/gp_Mat.lxx:192: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_XYZ.hxx:358,
from /usr/include/opencascade/gp_Trsf.hxx:35,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_XYZ.lxx: In member function ‘void gp_XYZ::Normalize()’:
/usr/include/opencascade/gp_XYZ.lxx:206: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_XYZ.lxx: In member function ‘gp_XYZ gp_XYZ::Normalized() const’:
/usr/include/opencascade/gp_XYZ.lxx:213: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Mat2d.hxx:292,
from /usr/include/opencascade/gp_Trsf2d.hxx:32,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘void gp_Mat2d::SetValue(Standard_Integer, Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Mat2d.lxx:62: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘const Standard_Real& gp_Mat2d::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Mat2d.lxx:76: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Mat2d.lxx: In member function ‘Standard_Real& gp_Mat2d::ChangeValue(Standard_Integer, Standard_Integer)’:
/usr/include/opencascade/gp_Mat2d.lxx:85: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_XY.hxx:318,
from /usr/include/opencascade/gp_Trsf2d.hxx:35,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_XY.lxx: In member function ‘void gp_XY::Normalize()’:
/usr/include/opencascade/gp_XY.lxx:140: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_XY.lxx: In member function ‘gp_XY gp_XY::Normalized() const’:
/usr/include/opencascade/gp_XY.lxx:147: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Dir2d.hxx:304,
from /usr/include/opencascade/gp_Vec2d.lxx:5,
from /usr/include/opencascade/gp_Vec2d.hxx:339,
from /usr/include/opencascade/gp_Pnt2d.lxx:6,
from /usr/include/opencascade/gp_Pnt2d.hxx:204,
from /usr/include/opencascade/gp_Trsf2d.lxx:4,
from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(const gp_Vec2d&)’:
/usr/include/opencascade/gp_Dir2d.lxx:19: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(const gp_XY&)’:
/usr/include/opencascade/gp_Dir2d.lxx:29: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In constructor ‘gp_Dir2d::gp_Dir2d(Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:38: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetCoord(Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:48: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx:52: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetCoord(Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:61: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetX(Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:70: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetY(Standard_Real)’:
/usr/include/opencascade/gp_Dir2d.lxx:79: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir2d.lxx: In member function ‘void gp_Dir2d::SetXY(const gp_XY&)’:
/usr/include/opencascade/gp_Dir2d.lxx:89: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Vec2d.hxx:339,
from /usr/include/opencascade/gp_Pnt2d.lxx:6,
from /usr/include/opencascade/gp_Pnt2d.hxx:204,
from /usr/include/opencascade/gp_Trsf2d.lxx:4,
from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Vec2d.lxx: In member function ‘void gp_Vec2d::Normalize()’:
/usr/include/opencascade/gp_Vec2d.lxx:140: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec2d.lxx: In member function ‘gp_Vec2d gp_Vec2d::Normalized() const’:
/usr/include/opencascade/gp_Vec2d.lxx:147: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Trsf2d.hxx:279,
from /usr/include/opencascade/gp_Trsf.lxx:7,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Trsf2d.lxx: In member function ‘Standard_Real gp_Trsf2d::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Trsf2d.lxx:85: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Dir.hxx:313,
from /usr/include/opencascade/gp_Vec.lxx:6,
from /usr/include/opencascade/gp_Vec.hxx:388,
from /usr/include/opencascade/gp_Trsf.lxx:8,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(const gp_Vec&)’:
/usr/include/opencascade/gp_Dir.lxx:18: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(const gp_XYZ&)’:
/usr/include/opencascade/gp_Dir.lxx:30: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In constructor ‘gp_Dir::gp_Dir(Standard_Real, Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:41: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetCoord(Standard_Integer, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:53: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx:58: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetCoord(Standard_Real, Standard_Real, Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:68: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetX(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:79: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetY(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:90: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetZ(Standard_Real)’:
/usr/include/opencascade/gp_Dir.lxx:101: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::SetXYZ(const gp_XYZ&)’:
/usr/include/opencascade/gp_Dir.lxx:113: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::Cross(const gp_Dir&)’:
/usr/include/opencascade/gp_Dir.lxx:170: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘gp_Dir gp_Dir::Crossed(const gp_Dir&) const’:
/usr/include/opencascade/gp_Dir.lxx:179: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘void gp_Dir::CrossCross(const gp_Dir&, const gp_Dir&)’:
/usr/include/opencascade/gp_Dir.lxx:189: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Dir.lxx: In member function ‘gp_Dir gp_Dir::CrossCrossed(const gp_Dir&, const gp_Dir&) const’:
/usr/include/opencascade/gp_Dir.lxx:199: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Vec.hxx:388,
from /usr/include/opencascade/gp_Trsf.lxx:8,
from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Vec.lxx: In member function ‘Standard_Real gp_Vec::Angle(const gp_Vec&) const’:
/usr/include/opencascade/gp_Vec.lxx:111: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘Standard_Real gp_Vec::AngleWithRef(const gp_Vec&, const gp_Vec&) const’:
/usr/include/opencascade/gp_Vec.lxx:120: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘void gp_Vec::Normalize()’:
/usr/include/opencascade/gp_Vec.lxx:213: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/gp_Vec.lxx: In member function ‘gp_Vec gp_Vec::Normalized() const’:
/usr/include/opencascade/gp_Vec.lxx:220: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/gp_Trsf.hxx:376,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/usr/include/opencascade/gp_Trsf.lxx: In member function ‘Standard_Real gp_Trsf::Value(Standard_Integer, Standard_Integer) const’:
/usr/include/opencascade/gp_Trsf.lxx:69: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/BRepTools_Modifier.hxx:131,
from /usr/include/opencascade/BRepBuilderAPI_ModifyShape.hxx:26,
from /usr/include/opencascade/BRepBuilderAPI_Transform.hxx:35,
from MakeBottle.cxx:8:
/usr/include/opencascade/BRepTools_Modifier.lxx: In member function ‘const TopoDS_Shape& BRepTools_Modifier::ModifiedShape(const TopoDS_Shape&) const’:
/usr/include/opencascade/BRepTools_Modifier.lxx:17: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/TopoDS_Iterator.hxx:142,
from /usr/include/opencascade/TopExp_Explorer.lxx:6,
from /usr/include/opencascade/TopExp_Explorer.hxx:220,
from MakeBottle.cxx:44:
/usr/include/opencascade/TopoDS_Iterator.lxx: In member function ‘const TopoDS_Shape& TopoDS_Iterator::Value() const’:
/usr/include/opencascade/TopoDS_Iterator.lxx:26: warning: deprecated conversion from string constant to ‘char*’
In file included from /usr/include/opencascade/TopoDS.hxx:168,
from MakeBottle.cxx:46:
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Vertex& TopoDS::Vertex(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:25: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Vertex& TopoDS::Vertex(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:37: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Edge& TopoDS::Edge(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:49: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Edge& TopoDS::Edge(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:61: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Wire& TopoDS::Wire(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:73: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Wire& TopoDS::Wire(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:85: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Face& TopoDS::Face(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:97: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Face& TopoDS::Face(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:109: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Shell& TopoDS::Shell(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:121: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Shell& TopoDS::Shell(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:133: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Solid& TopoDS::Solid(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:145: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Solid& TopoDS::Solid(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:157: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_CompSolid& TopoDS::CompSolid(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:169: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_CompSolid& TopoDS::CompSolid(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:181: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static const TopoDS_Compound& TopoDS::Compound(const TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:193: warning: deprecated conversion from string constant to ‘char*’
/usr/include/opencascade/TopoDS.lxx: In static member function ‘static TopoDS_Compound& TopoDS::Compound(TopoDS_Shape&)’:
/usr/include/opencascade/TopoDS.lxx:205: warning: deprecated conversion from string constant to ‘char*’
jonas@Ubuntu4:~/OCC_bottle$

This is the contents of /usr/include/opencascade/config.h:

/* config.h.  Generated from config.h.in by configure.  */
/* config.h.in.  Generated from configure.in by autoheader.  */

/* Define to one of _getb67′, GETB67', getb67′ for Cray-2 and Cray-YMP
systems. This function is required for alloca.c' support on those systems.
*/
/* #undef CRAY_STACKSEG_END */

/* Define to 1 if using alloca.c’. */
/* #undef C_ALLOCA */

/* define if the compiler allows redefinition of stream input and output */
/* #undef DEF_IOS_OK */

/* Define to 1 if you have alloca', as a function or macro. */
#define HAVE_ALLOCA 1

/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#define HAVE_ALLOCA_H 1

/* Define to 1 if you have the <bits/sigset.h> header file. */
#define HAVE_BITS_SIGSET_H 1

/* Define to 1 if you have the <bstring.h> header file. */
/* #undef HAVE_BSTRING_H */

/* Define to 1 if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <dl.h> header file. */
/* #undef HAVE_DL_H */

/* Define to 1 if you have the <DPS/dpsXclient.h> header file. */
/* #undef HAVE_DPS_DPSXCLIENT_H */

/* Define if we have a function called "finite" in -lm. */
#define HAVE_FINITE

/* Define to 1 if you have the <floatingpoint.h> header file. */
/* #undef HAVE_FLOATINGPOINT_H */

/* Define to 1 if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1

/* Define to 1 if you have the <fstream> header file. */
#define HAVE_FSTREAM 1

/* Define to 1 if you have the <fstream.h> header file. */
/* #undef HAVE_FSTREAM_H */

/* Define to 1 if you have the gethostname’ function. */
#define HAVE_GETHOSTNAME 1

/* Define to 1 if you have the <getopt.h> header file. */
#define HAVE_GETOPT_H 1

/* Define to 1 if you have the <ieeefp.h> header file. */
/* #undef HAVE_IEEEFP_H */

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <iomanip> header file. */
#define HAVE_IOMANIP 1

/* Define to 1 if you have the <iomanip.h> header file. */
/* #undef HAVE_IOMANIP_H */

/* Define to 1 if you have the <ios> header file. */
#define HAVE_IOS 1

/* Define to 1 if you have the <iostream> header file. */
#define HAVE_IOSTREAM 1

/* Define to 1 if you have the <iostream.h> header file. */
/* #undef HAVE_IOSTREAM_H */

/* Define to 1 if you have the <ios.h> header file. */
/* #undef HAVE_IOS_H */

/* Define to 1 if you have the <istream> header file. */
#define HAVE_ISTREAM 1

/* Define to 1 if you have the <istream.h> header file. */
/* #undef HAVE_ISTREAM_H */

/* Define to 1 if you have the <libc.h> header file. */
/* #undef HAVE_LIBC_H */

/* Define to 1 if you have the e' library (-le). */
/* #undef HAVE_LIBE */

/* Define to 1 if you have the inks’ library (-links). */
/* #undef HAVE_LIBINKS */

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define if we have a function called “mallinfo” in -lmalloc. */
/* #undef HAVE_MALLINFO */

/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <ndir.h> header file. */
/* #undef HAVE_NDIR_H */

/* Define to 1 if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define to 1 if you have the <net/if.h> header file. */
#define HAVE_NET_IF_H 1

/* Define to 1 if you have the <osfcn.h> header file. */
/* #undef HAVE_OSFCN_H */

/* Define to 1 if you have the <ostream> header file. */
#define HAVE_OSTREAM 1

/* Define to 1 if you have the <ostream.h> header file. */
/* #undef HAVE_OSTREAM_H */

/* Define to 1 if you have the putenv' function. */
#define HAVE_PUTENV 1

/* Define to 1 if you have the <pwd.h> header file. */
#define HAVE_PWD_H 1

/* Define to 1 if you have the regcomp’ function. */
#define HAVE_REGCOMP 1

/* Define to 1 if you have the re_comp' function. */
#define HAVE_RE_COMP 1

/* Define to 1 if you have the <sigfpe.h> header file. */
/* #undef HAVE_SIGFPE_H */

/* Define to 1 if you have the <siginfo.h> header file. */
/* #undef HAVE_SIGINFO_H */

/* Define to 1 if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define to 1 if you have the statfs’ function. */
#define HAVE_STATFS 1

/* Define to 1 if you have the statvfs' function. */
#define HAVE_STATVFS 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the strcspn’ function. */
#define HAVE_STRCSPN 1

/* Define to 1 if you have the strdup' function. */
#define HAVE_STRDUP 1

/* Define to 1 if you have the <stream.h> header file. */
/* #undef HAVE_STREAM_H */

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <strstream.h> header file. */
/* #undef HAVE_STRSTREAM_H */

/* Define to 1 if you have the strtol’ function. */
#define HAVE_STRTOL 1

/* Define if we have a function called “ieee_handler” in -lsunmath. */
/* #undef HAVE_SUNMATH */

/* Define to 1 if you have the <sysent.h> header file. */
/* #undef HAVE_SYSENT_H */

/* Define to 1 if you have the <sys/dir.h> header file. */
#define HAVE_SYS_DIR_H 1

/* Define to 1 if you have the <sys/filio.h> header file. */
/* #undef HAVE_SYS_FILIO_H */

/* Define to 1 if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* Define to 1 if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define to 1 if you have the <sys/machsig.h> header file. */
/* #undef HAVE_SYS_MACHSIG_H */

/* Define to 1 if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define to 1 if you have the <sys/ndir.h> header file. */
/* #undef HAVE_SYS_NDIR_H */

/* Define to 1 if you have the <sys/param.h> header file. */
#define HAVE_SYS_PARAM_H 1

/* Define to 1 if you have the <sys/select.h> header file. */
#define HAVE_SYS_SELECT_H 1

/* Define to 1 if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define to 1 if you have the <sys/siginfo.h> header file. */
/* #undef HAVE_SYS_SIGINFO_H */

/* Define to 1 if you have the <sys/signal.h> header file. */
#define HAVE_SYS_SIGNAL_H 1

/* Define to 1 if you have the <sys/socket.h> header file. */
#define HAVE_SYS_SOCKET_H 1

/* Define to 1 if you have the <sys/statvfs.h> header file. */
#define HAVE_SYS_STATVFS_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/systeminfo.h> header file. */
/* #undef HAVE_SYS_SYSTEMINFO_H */

/* Define to 1 if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define to 1 if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define to 1 if you have the <sys/vfs.h> header file. */
#define HAVE_SYS_VFS_H 1

/* Define to 1 if you have the <sys/vnode.h> header file. */
/* #undef HAVE_SYS_VNODE_H */

/* Define to 1 if you have the <time.h> header file. */
#define HAVE_TIME_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define to 1 if you have the <X11/extensions/multibuf.h> header file. */
#define HAVE_X11_EXTENSIONS_MULTIBUF_H 1

/* Define to 1 if you have the <X11/extensions/readdisplay.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_READDISPLAY_H */

/* Define to 1 if you have the <X11/extensions/transovl.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_TRANSOVL_H */

/* Define to 1 if you have the <Xmu/Editres.h> header file. */
#define HAVE_XMU_EDITRES_H 1

/* Define to 1 if your C compiler doesn’t accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* define if the class ostream has member function form */
/* #undef OSTREAM_FORM_OK */

/* Name of package */
#define PACKAGE “opencas”

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT “”

/* Define to the full name of this package. */
#define PACKAGE_NAME “OpenCAS”

/* Define to the full name and version of this package. */
#define PACKAGE_STRING “OpenCAS 5.0DVP1”

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME “opencas”

/* Define to the version of this package. */
#define PACKAGE_VERSION “5.0DVP1”

/* Define to 1 if the C compiler supports function prototypes. */
#define PROTOTYPES 1

/* Define as the return type of signal handlers (int' or void’). */
#define RETSIGTYPE void

/* define if the function semctl takes a value */
/* #undef SEMCTL_NO_REFERENCE */

/* define if the function semop takes a value */
/* #undef SEMOP_NO_REFERENCE */

/* define if semun has member __buf */
/* #undef SEMUN_BUF_DEFINED */

/* define if the union semun is in sys/sem.h */
/* #undef SEMUN_DEFINED */

/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define to 1 if your <sys/time.h> declares struct tm'. */
/* #undef TM_IN_SYS_TIME */

/* Version number of package */
#define VERSION "5.0DVP1"

/* Define to 1 if your processor stores words with the most significant byte
first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */

/* Define to 1 if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
/* # undef _ALL_SOURCE */
#endif

/* Define like PROTOTYPES; this can be used by system headers. */
#define __PROTOTYPES 1

/* Define to unsigned int’ if <sys/types.h> does not define. */
/* #undef size_t */

Posted in Uncategorized | Leave a comment

Part 1)Experiments on getting OpenCascade MakeBottle.cxx to compile on Hardy Heron 32-bit using g++ compiler

I’ve been trying to get MakeBottle.cxx to compile on my 32-bit Hardy Heron…    As I’ve said from the beginning of me starting to post, I’ve been pursuing three simultaneous learning objectives…

  1. Linux,
  2. C++
  3. OpenCascade

As this is a fun[?] project for me, I haven’t been able to focus on this as much as I’d like. At this point, I’m starting to learn about compiler options using the g++ compiler.

Here are my experiments in trying get MakeBottle.cxx to compile successfully

(Experiment 1) Find make MakeBottle.cxx and simply let the g++ rip.

jonas@Ubuntu4:~$ locate MakeBottle.cxx
/home/jonas/OCC_bottle/MakeBottle.cxx
/opt/OpenCASCADE6.2.0/samples/tutorial/src/MakeBottle.cxx
jonas@Ubuntu4:~$ cd /opt/OpenCASCADE6.2.0/samples/tutorial/src/
jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$ g++ MakeBottle.cxx
MakeBottle.cxx:1:25: error: BRep_Tool.hxx: No such file or directory
MakeBottle.cxx:3:32: error: BRepAlgoAPI_Fuse.hxx: No such file or directory
MakeBottle.cxx:5:39: error: BRepBuilderAPI_MakeEdge.hxx: No such file or directory
MakeBottle.cxx:6:39: error: BRepBuilderAPI_MakeFace.hxx: No such file or directory
MakeBottle.cxx:7:39: error: BRepBuilderAPI_MakeWire.hxx: No such file or directory
MakeBottle.cxx:8:40: error: BRepBuilderAPI_Transform.hxx: No such file or directory
MakeBottle.cxx:10:40: error: BRepFilletAPI_MakeFillet.hxx: No such file or directory
MakeBottle.cxx:12:23: error: BRepLib.hxx: No such file or directory
MakeBottle.cxx:14:44: error: BRepOffsetAPI_MakeThickSolid.hxx: No such file or directory
MakeBottle.cxx:15:42: error: BRepOffsetAPI_ThruSections.hxx: No such file or directory
MakeBottle.cxx:17:40: error: BRepPrimAPI_MakeCylinder.hxx: No such file or directory
MakeBottle.cxx:18:37: error: BRepPrimAPI_MakePrism.hxx: No such file or directory
MakeBottle.cxx:20:34: error: GC_MakeArcOfCircle.hxx: No such file or directory
MakeBottle.cxx:21:30: error: GC_MakeSegment.hxx: No such file or directory
MakeBottle.cxx:23:33: error: GCE2d_MakeSegment.hxx: No such file or directory
MakeBottle.cxx:25:18: error: gp.hxx: No such file or directory
MakeBottle.cxx:26:22: error: gp_Ax1.hxx: No such file or directory
MakeBottle.cxx:27:22: error: gp_Ax2.hxx: No such file or directory
MakeBottle.cxx:28:23: error: gp_Ax2d.hxx: No such file or directory
MakeBottle.cxx:29:22: error: gp_Dir.hxx: No such file or directory
MakeBottle.cxx:30:24: error: gp_Dir2d.hxx: No such file or directory
MakeBottle.cxx:31:22: error: gp_Pnt.hxx: No such file or directory
MakeBottle.cxx:32:24: error: gp_Pnt2d.hxx: No such file or directory
MakeBottle.cxx:33:23: error: gp_Trsf.hxx: No such file or directory
MakeBottle.cxx:34:22: error: gp_Vec.hxx: No such file or directory
MakeBottle.cxx:36:39: error: Geom_CylindricalSurface.hxx: No such file or directory
MakeBottle.cxx:37:26: error: Geom_Plane.hxx: No such file or directory
MakeBottle.cxx:38:28: error: Geom_Surface.hxx: No such file or directory
MakeBottle.cxx:39:33: error: Geom_TrimmedCurve.hxx: No such file or directory
MakeBottle.cxx:41:30: error: Geom2d_Ellipse.hxx: No such file or directory
MakeBottle.cxx:42:35: error: Geom2d_TrimmedCurve.hxx: No such file or directory
MakeBottle.cxx:44:31: error: TopExp_Explorer.hxx: No such file or directory
MakeBottle.cxx:46:22: error: TopoDS.hxx: No such file or directory
MakeBottle.cxx:47:27: error: TopoDS_Edge.hxx: No such file or directory
MakeBottle.cxx:48:27: error: TopoDS_Face.hxx: No such file or directory
MakeBottle.cxx:49:27: error: TopoDS_Wire.hxx: No such file or directory
MakeBottle.cxx:50:28: error: TopoDS_Shape.hxx: No such file or directory
MakeBottle.cxx:51:31: error: TopoDS_Compound.hxx: No such file or directory
MakeBottle.cxx:53:36: error: TopTools_ListOfShape.hxx: No such file or directory
MakeBottle.cxx:55: error: ‘TopoDS_Shape’ does not name a type

Experiment result
The g++ library by default is not point to the Occ library.
I think there is probably a way to include the library by default by the compiler.  I haven’t gone done those paths yet.  I found the library by the following:

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$ locate BRep_Tool.hxx
/opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx

(Experiment 2)Compiling with the OCC library using the -I option
I trying a couple of different ways to get the g++ compiler to recognize OCC library contained in the  /opt/OpenCASCADE6.2.0/ros/inc/ directory. Partial results from that are listed below:

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$ g++ -I /opt/OpenCASCADE6.2.0/ros/inc MakeBottle.cxx
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:9,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Address.hxx:21,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:28,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_values.h:35:2: error: #error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_OStream.hxx:7,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:40,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Stream.hxx:19:2: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_OutOfRange.hxx:33,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.lxx:4,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.hxx:326,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Trsf.hxx:32,
from /opt/OpenCASCADE6.2.0/ros/inc/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_SStream.hxx:23:4: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Address.hxx:21,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:28,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerFirst()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:129: error: ‘INT_MIN’ was not declared in this scope
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerLast()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:135: error: ‘INT_MAX’ was not declared in this scope
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerSize()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:141: error: ‘CHAR_BIT’ was not declared in this scope
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_PrimitiveTypes.hxx:23,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Standard_Transient.hxx:10,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_MMgt_TShared.hxx:33,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Geometry.hxx:33,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:33,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1 …………………….. There’s more but this enough to get the idea.

Ok… the next place MakeBottle.Cxx crapped out was with the config.h files and the variables HAVE_IOSTREAM or HAVE_IOSTREAM_H.   I searched the OpenCascade forum and ran across a post saying that the either one or the other should be defined I ran across a post that either one or the other variable should be used and you could delete the variable by using the -D variable.
I tried to a few experiments but I came to the conclusion that my compiler wants to use <iostream> instead of <iostream.h> and so forth.   So….. rather the messing with the -D variable, I decided to try making manual edits to the config.h and see what happens.  I guess I should point out, I haven’t found documentation or posts to do this, but it seemed logical to me.  I guess the results of the next experiment will dictate where or not this was a dumb idea……

It found a few reference to config.h which look like likely suspects.  Here they are.

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$ locate config.h
/opt/OpenCASCADE6.2.0/ros/config.h.in
/opt/OpenCASCADE6.2.0/ros/inc/config.h
/opt/OpenCASCADE6.2.0/ros/src/WOKTclLib/config.h
/opt/OpenCASCADE6.2.0/wok/lib/config.h

I decide to go try modifying /opt/OpenCASCADE6.2.0/ros/inc/config.h and see what happens.
Here is the unmodified contents of this file:

#ifdef HAVE_WOK_CONFIG_H

/*———————————————————*/
/* This part is extracted from config.h generated on Linux */
/*———————————————————*/

#ifdef LIN

/* This part is extracted from config.h generated on Linux */

/* config.h.  Generated automatically by configure.  */
/* config.h.in.  Generated automatically from configure.ac by autoheader.  */

/* Define to one of _getb67', GETB67′, getb67' for Cray-2 and Cray-YMP
systems. This function is required for
alloca.c’ support on those systems.
*/
/* #undef CRAY_STACKSEG_END */

/* Define to 1 if using alloca.c'. */
/* #undef C_ALLOCA */

/* define if the compiler allows redefinition of stream input and output */
#undef DEF_IOS_OK

/* Define to 1 if you have alloca’, as a function or macro. */
#define HAVE_ALLOCA_H 1

#define HAVE_FSTREAM 1

#define HAVE_IOSTREAM 1
#define HAVE_IOMANIP 1
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#define HAVE_ALLOCA_H 1

/* Define to 1 if you have the <bits/sigset.h> header file. */
#define HAVE_BITS_SIGSET_H 1

/* Define to 1 if you have the <bstring.h> header file. */
/* #undef HAVE_BSTRING_H */

/* Define to 1 if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <dl.h> header file. */
/* #undef HAVE_DL_H */

/* Define if we have the Adobe postscript library -ldps. */
/* #undef HAVE_DPS */

/* Define to 1 if you have the <DPS/dpsXclient.h> header file. */
#define HAVE_DPS_DPSXCLIENT_H 1

/* Define if we have a function called “finite” in -lm. */
#define HAVE_FINITE

/* Define to 1 if you have the <floatingpoint.h> header file. */
/* #undef HAVE_FLOATINGPOINT_H */

/* Define to 1 if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1

/* Define to 1 if you have the gethostname' function. */
#define HAVE_GETHOSTNAME 1

/* Define to 1 if you have the <getopt.h> header file. */
#define HAVE_GETOPT_H 1

/* Define to 1 if you have the <ieeefp.h> header file. */
/* #undef HAVE_IEEEFP_H */

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <iomanip.h> header file. */
#define HAVE_IOMANIP_H 1

/* Define to 1 if you have the <ios> header file. */
#define HAVE_IOS 1

/* Define to 1 if you have the <ios.h> header file. */
/* #undef HAVE_IOS_H */

/* Define to 1 if you have the <istream.h> header file. */
#define HAVE_ISTREAM 1

/* Define to 1 if you have the <libc.h> header file. */
/* #undef HAVE_LIBC_H */

/* Define to 1 if you have the e’ library (-le). */
/* #undef HAVE_LIBE */

/* Define to 1 if you have the inks' library (-links). */
/* #undef HAVE_LIBINKS */

/* Define to 1 if you have the <limits> header file. */
#define HAVE_LIMITS_H 1

/* Define if we have a function called "mallinfo" in -lmalloc. */
/* #undef HAVE_MALLINFO */

/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <ndir.h> header file. */
/* #undef HAVE_NDIR_H */

/* Define to 1 if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define to 1 if you have the <net/if.h> header file. */
#define HAVE_NET_IF_H 1

/* Define to 1 if you have the <osfcn.h> header file. */
/* #undef HAVE_OSFCN_H */

/* Define if you have the putenv’ function. */
#define HAVE_PUTENV 1

/* Define to 1 if you have the <pwd.h> header file. */
#define HAVE_PWD_H 1

/* Define to 1 if you have the regcomp' function. */
#define HAVE_REGCOMP 1

/* Define to 1 if you have the re_comp’ function. */
#define HAVE_RE_COMP 1

/* Define to 1 if you have the <sigfpe.h> header file. */
/* #undef HAVE_SIGFPE_H */

/* Define to 1 if you have the <siginfo.h> header file. */
/* #undef HAVE_SIGINFO_H */

/* Define to 1 if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define to 1 if you have the statfs' function. */
#define HAVE_STATFS 1

/* Define to 1 if you have the statvfs’ function. */
#define HAVE_STATVFS 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the strcspn' function. */
#define HAVE_STRCSPN 1

/* Define to 1 if you have the strdup’ function. */
#define HAVE_STRDUP 1

/* Define to 1 if you have the <stream.h> header file. */
#define HAVE_STREAM_H 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <strstream.h> header file. */
#define HAVE_STRSTREAM_H 1

/* Define if you have the strtol' function. */
#define HAVE_STRTOL 1

/* Define if we have a function called "ieee_handler" in -lsunmath. */
/* #undef HAVE_SUNMATH */

/* Define to 1 if you have the <sysent.h> header file. */
/* #undef HAVE_SYSENT_H */

/* Define to 1 if you have the <sys/dir.h> header file. */
#define HAVE_SYS_DIR_H 1

/* Define to 1 if you have the <sys/filio.h> header file. */
/* #undef HAVE_SYS_FILIO_H */

/* Define to 1 if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* Define to 1 if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define to 1 if you have the <sys/machsig.h> header file. */
/* #undef HAVE_SYS_MACHSIG_H */

/* Define to 1 if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define to 1 if you have the <sys/ndir.h> header file. */
/* #undef HAVE_SYS_NDIR_H */

/* Define to 1 if you have the <sys/param.h> header file. */
#define HAVE_SYS_PARAM_H 1

/* Define to 1 if you have the <sys/select.h> header file. */
#define HAVE_SYS_SELECT_H 1

/* Define to 1 if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define to 1 if you have the <sys/siginfo.h> header file. */
/* #undef HAVE_SYS_SIGINFO_H */

/* Define to 1 if you have the <sys/signal.h> header file. */
#define HAVE_SYS_SIGNAL_H 1

/* Define to 1 if you have the <sys/socket.h> header file. */
#define HAVE_SYS_SOCKET_H 1

/* Define to 1 if you have the <sys/statvfs.h> header file. */
#define HAVE_SYS_STATVFS_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/systeminfo.h> header file. */
/* #undef HAVE_SYS_SYSTEMINFO_H */

/* Define to 1 if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define to 1 if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define to 1 if you have the <sys/vfs.h> header file. */
#define HAVE_SYS_VFS_H 1

/* Define to 1 if you have the <sys/vnode.h> header file. */
/* #undef HAVE_SYS_VNODE_H */

/* Define to 1 if you have the <time.h> header file. */
#define HAVE_TIME_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define to 1 if you have the <X11/extensions/multibuf.h> header file. */
#define HAVE_X11_EXTENSIONS_MULTIBUF_H 1

/* Define to 1 if you have the <X11/extensions/readdisplay.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_READDISPLAY_H */

/* Define to 1 if you have the <X11/extensions/transovl.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_TRANSOVL_H */

/* Define if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* define if the class ostream has member function form */
#define OSTREAM_FORM_OK

/* Name of package */
#define PACKAGE "OpenCAS"

/* Define if compiler has function prototypes */
#define PROTOTYPES 1

/* Define as the return type of signal handlers (int’ or void'). */
#define RETSIGTYPE void

/* define if the function semctl takes a value */
/* #undef SEMCTL_NO_REFERENCE */

/* define if the function semop takes a value */
/* #undef SEMOP_NO_REFERENCE */

/* define if semun has member __buf */
/* #undef SEMUN_BUF_DEFINED */

/* define if the union semun is in sys/sem.h */
/* #undef SEMUN_DEFINED */

/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */

/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define if your <sys/time.h> declares struct tm’. */
/* #undef TM_IN_SYS_TIME */

/* Version number of package */
#define VERSION “4.0DVP1”

/* Define if your processor stores words with the most significant byte first
(like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */

/* Define if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
/* # undef _ALL_SOURCE */
#endif

/* Define if you need to in order for stat and other things to work. */
/* #undef _POSIX_SOURCE */

/* Define to unsigned' if <sys/types.h> does not define. */
/* #undef size_t */

/* End Linux Part */

/*---------------------------------------------------------*/
/* This part is extracted from config.h generated on SOLARIS */
/*---------------------------------------------------------*/

#elif SOLARIS

/* config.h.  Generated automatically by configure.  */
/* config.h.in.  Generated automatically from configure.ac by autoheader.  */

/* Define to one of _getb67′, GETB67', getb67′ for Cray-2 and Cray-YMP
systems. This function is required for alloca.c' support on those systems.
*/
/* #undef CRAY_STACKSEG_END */

/* Define if using alloca.c’. */
#define C_ALLOCA 1
#define HAVE_FSTREAM_H 1

#define HAVE_IOSTREAM_H 1

/* define if the compiler allows redefinition of stream input and output */
/* #undef DEF_IOS_OK */

/* Define if you have alloca', as a function or macro. */
/* #undef HAVE_ALLOCA */

/* Define if you have <alloca.h> and it should be used (not on Ultrix). */
#define HAVE_ALLOCA_H

/* Define if you have the <bits/sigset.h> header file. */
/* #undef HAVE_BITS_SIGSET_H */

/* Define if you have the <bstring.h> header file. */
/* #undef HAVE_BSTRING_H */

/* Define if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define if you have the <dl.h> header file. */
/* #undef HAVE_DL_H */

/* Define if we have the Adobe postscript library -ldps. */
/* #undef HAVE_DPS */

/* Define if you have the <DPS/dpsXclient.h> header file. */
/* #undef HAVE_DPS_DPSXCLIENT_H */

/* Define if we have a function called "finite" in -lm. */
#define HAVE_FINITE

/* Define if you have the <floatingpoint.h> header file. */
#define HAVE_FLOATINGPOINT_H 1

/* Define if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1

/* Define if you have the gethostname’ function. */
/* #undef HAVE_GETHOSTNAME */

/* Define if you have the <getopt.h> header file. */
/* #undef HAVE_GETOPT_H */

/* Define if you have the <ieeefp.h> header file. */
#define HAVE_IEEEFP_H 1

/* Define if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define if you have the <iomanip.h> header file. */
#define HAVE_IOMANIP_H 1

/* Define if you have the <istream.h> header file. */
/* #undef HAVE_ISTREAM_H */

/* Define if you have the <fstream> header file. */
/* #undef HAVE_FSTREAM */

/* Define if you have the <strstream> header file. */
/* #undef HAVE_STRSTREAM */

/* Define if you have the <libc.h> header file. */
/* #undef HAVE_LIBC_H */

/* Define if you have the e' library (-le). */
/* #undef HAVE_LIBE */

/* Define if you have the inks’ library (-links). */
/* #undef HAVE_LIBINKS */

/* Define if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define if we have a function called “mallinfo” in -lmalloc. */
#define HAVE_MALLINFO

/* Define if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define if you have the <ndir.h> header file. */
/* #undef HAVE_NDIR_H */

/* Define if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define if you have the <net/if.h> header file. */
/* #define HAVE_NET_IF_H 1 */

/* Define if you have the <osfcn.h> header file. */
/* #undef HAVE_OSFCN_H */

/* Define if you have the putenv' function. */
/* #undef HAVE_PUTENV */

/* Define if you have the <pwd.h> header file. */
#define HAVE_PWD_H 1

/* Define if you have the regcomp’ function. */
/* #undef HAVE_REGCOMP */

/* Define if you have the re_comp' function. */
/* #undef HAVE_RE_COMP */

/* Define if you have the <sigfpe.h> header file. */
/* #undef HAVE_SIGFPE_H */

/* Define if you have the <siginfo.h> header file. */
#define HAVE_SIGINFO_H 1

/* Define if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define if you have the statfs’ function. */
/* #undef HAVE_STATFS */
#define HAVE_STATVFS

/* Define if you have the statvfs' function. */
/* #undef HAVE_STATVFS */

/* Define if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define if you have the strcspn’ function. */
/* #undef HAVE_STRCSPN */

/* Define if you have the strdup' function. */
/* #undef HAVE_STRDUP */

/* Define if you have the <stream.h> header file. */
/* #undef HAVE_STREAM_H */

/* Define if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define if you have the <strstream.h> header file. */
/* #undef HAVE_STRSTREAM_H */

/* Define if you have the strtol’ function. */
/* #undef HAVE_STRTOL */

/* Define if we have a function called “ieee_handler” in -lsunmath. */
#define HAVE_SUNMATH

/* Define if you have the <sysent.h> header file. */
/* #undef HAVE_SYSENT_H */

/* Define if you have the <sys/dir.h> header file. */
/* #undef HAVE_SYS_DIR_H */

/* Define if you have the <sys/filio.h> header file. */
#define HAVE_SYS_FILIO_H 1

/* Define if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* Define if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define if you have the <sys/machsig.h> header file. */
#define HAVE_SYS_MACHSIG_H 1

/* Define if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define if you have the <sys/ndir.h> header file. */
/* #undef HAVE_SYS_NDIR_H */

/* Define if you have the <sys/param.h> header file. */
#define HAVE_SYS_PARAM_H 1

/* Define if you have the <sys/select.h> header file. */
#define HAVE_SYS_SELECT_H 1

/* Define if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define if you have the <sys/siginfo.h> header file. */
#define HAVE_SYS_SIGINFO_H 1

/* Define if you have the <sys/signal.h> header file. */
#define HAVE_SYS_SIGNAL_H 1

/* Define if you have the <sys/socket.h> header file. */
/* #define HAVE_SYS_SOCKET_H 1 */

/* Define if you have the <sys/statvfs.h> header file. */
#define HAVE_SYS_STATVFS_H 1

/* Define if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define if you have the <sys/systeminfo.h> header file. */
#define HAVE_SYS_SYSTEMINFO_H 1

/* Define if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1

/* Define if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define if you have the <sys/vfs.h> header file. */
#define HAVE_SYS_VFS_H 1

/* Define if you have the <sys/vnode.h> header file. */
#define HAVE_SYS_VNODE_H 1

/* Define if you have the <time.h> header file. */
#define HAVE_TIME_H 1

/* Define if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define if you have the <X11/extensions/multibuf.h> header file. */
#define HAVE_X11_EXTENSIONS_MULTIBUF_H 1

/* Define if you have the <X11/extensions/readdisplay.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_READDISPLAY_H */

/* Define if you have the <X11/extensions/transovl.h> header file. */
#define HAVE_X11_EXTENSIONS_TRANSOVL_H 1

/* Define if your C compiler doesn’t accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* define if the class ostream has member function form */
/* #undef OSTREAM_FORM_OK */

/* Name of package */
#define PACKAGE “OpenCAS”

/* Define if compiler has function prototypes */
#define PROTOTYPES 1

/* Define as the return type of signal handlers (int' or void’). */
#define RETSIGTYPE int

/* define if the function semctl takes a value */
/* #undef SEMCTL_NO_REFERENCE */

/* define if the function semop takes a value */
/* #undef SEMOP_NO_REFERENCE */

/* define if semun has member __buf */
/* #undef SEMUN_BUF_DEFINED */

/* define if the union semun is in sys/sem.h */
/* #undef SEMUN_DEFINED */

/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
#define STACK_DIRECTION -1

/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define if your <sys/time.h> declares struct tm'. */
#define TM_IN_SYS_TIME 1

/* Version number of package */
#define VERSION "4.0DVP1"

/* Define if your processor stores words with the most significant byte first
(like Motorola and SPARC, unlike Intel and VAX). */
#define WORDS_BIGENDIAN 1

/* Define if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
/* # undef _ALL_SOURCE */
#endif

/* Define if you need to in order for stat and other things to work. */
/* #undef _POSIX_SOURCE */

/* Define to unsigned’ if <sys/types.h> does not define. */
/* #define size_t unsigned */

/* End Solaris Part */

/*———————————————————*/
/* This part is extracted from config.h generated on IRIX */
/*———————————————————*/

#elif IRIX

/* config.h.  Generated automatically by configure.  */
/* config.h.in.  Generated automatically from configure.ac by autoheader.  */

/* Define to one of _getb67', GETB67′, getb67' for Cray-2 and Cray-YMP
systems. This function is required for
alloca.c’ support on those systems.
*/
/* #undef CRAY_STACKSEG_END */

/* Define to 1 if using alloca.c'. */
/* #undef C_ALLOCA */

/* define if the compiler allows redefinition of stream input and output */
/* #undef DEF_IOS_OK */

/* Define to 1 if you have alloca’, as a function or macro. */
#define HAVE_ALLOCA 1

/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#define HAVE_ALLOCA_H 1

/* Define to 1 if you have the <bits/sigset.h> header file. */
/* #undef HAVE_BITS_SIGSET_H */

/* Define to 1 if you have the <bstring.h> header file. */
#define HAVE_BSTRING_H 1

/* Define to 1 if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <dl.h> header file. */
/* #undef HAVE_DL_H */

/* Define to 1 if you have the <DPS/dpsXclient.h> header file. */
/* #undef HAVE_DPS_DPSXCLIENT_H */

/* Define if we have a function called “finite” in -lm. */
#define HAVE_FINITE

/* Define to 1 if you have the <floatingpoint.h> header file. */
/* #undef HAVE_FLOATINGPOINT_H */

/* Define to 1 if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1

/* Define to 1 if you have the <fstream> header file. */
#define HAVE_FSTREAM 1

/* Define to 1 if you have the <fstream.h> header file. */
#define HAVE_FSTREAM_H 1

/* Define to 1 if you have the gethostname' function. */
#define HAVE_GETHOSTNAME 1

/* Define to 1 if you have the <getopt.h> header file. */
#define HAVE_GETOPT_H 1

/* Define to 1 if you have the <ieeefp.h> header file. */
#define HAVE_IEEEFP_H 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <iomanip> header file. */
#define HAVE_IOMANIP 1

/* Define to 1 if you have the <iomanip.h> header file. */
#define HAVE_IOMANIP_H 1

/* Define to 1 if you have the <ios> header file. */
#define HAVE_IOS 1

/* Define to 1 if you have the <iostream> header file. */
#define HAVE_IOSTREAM 1

/* Define to 1 if you have the <iostream.h> header file. */
#define HAVE_IOSTREAM_H 1

/* Define to 1 if you have the <ios.h> header file. */
/* #undef HAVE_IOS_H */

/* Define to 1 if you have the <istream> header file. */
#define HAVE_ISTREAM 1

/* Define to 1 if you have the <istream.h> header file. */
/* #undef HAVE_ISTREAM_H */

/* Define to 1 if you have the <libc.h> header file. */
#define HAVE_LIBC_H 1

/* Define to 1 if you have the e’ library (-le). */
/* #undef HAVE_LIBE */

/* Define to 1 if you have the inks' library (-links). */
/* #undef HAVE_LIBINKS */

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define if we have a function called "mallinfo" in -lmalloc. */
#define HAVE_MALLINFO

/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <ndir.h> header file. */
/* #undef HAVE_NDIR_H */

/* Define to 1 if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define to 1 if you have the <net/if.h> header file. */
#define HAVE_NET_IF_H 1

/* Define to 1 if you have the <osfcn.h> header file. */
/* #undef HAVE_OSFCN_H */

/* Define to 1 if you have the <ostream> header file. */
#define HAVE_OSTREAM 1

/* Define to 1 if you have the <ostream.h> header file. */
/* #undef HAVE_OSTREAM_H */

/* Define to 1 if you have the putenv’ function. */
/* #undef HAVE_PUTENV */

/* Define to 1 if you have the <pwd.h> header file. */
#define HAVE_PWD_H 1

/* Define to 1 if you have the regcomp' function. */
#define HAVE_REGCOMP 1

/* Define to 1 if you have the re_comp’ function. */
#define HAVE_RE_COMP 1

/* Define to 1 if you have the <sigfpe.h> header file. */
#define HAVE_SIGFPE_H 1

/* Define to 1 if you have the <siginfo.h> header file. */
#define HAVE_SIGINFO_H 1

/* Define to 1 if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define to 1 if you have the statfs' function. */
#define HAVE_STATFS 1

/* Define to 1 if you have the statvfs’ function. */
#define HAVE_STATVFS 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the strcspn' function. */
#define HAVE_STRCSPN 1

/* Define to 1 if you have the strdup’ function. */
#define HAVE_STRDUP 1

/* Define to 1 if you have the <stream.h> header file. */
#define HAVE_STREAM_H 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <strstream.h> header file. */
#define HAVE_STRSTREAM_H 1

/* Define to 1 if you have the strtol' function. */
/* #undef HAVE_STRTOL */

/* Define if we have a function called "ieee_handler" in -lsunmath. */
/* #undef HAVE_SUNMATH */

/* Define to 1 if you have the <sysent.h> header file. */
/* #undef HAVE_SYSENT_H */

/* Define to 1 if you have the <sys/dir.h> header file. */
#define HAVE_SYS_DIR_H 1

/* Define to 1 if you have the <sys/filio.h> header file. */
#define HAVE_SYS_FILIO_H 1

/* Define to 1 if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* Define to 1 if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define to 1 if you have the <sys/machsig.h> header file. */
/* #undef HAVE_SYS_MACHSIG_H */

/* Define to 1 if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define to 1 if you have the <sys/ndir.h> header file. */
/* #undef HAVE_SYS_NDIR_H */

/* Define to 1 if you have the <sys/param.h> header file. */
#define HAVE_SYS_PARAM_H 1

/* Define to 1 if you have the <sys/select.h> header file. */
#define HAVE_SYS_SELECT_H 1

/* Define to 1 if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define to 1 if you have the <sys/siginfo.h> header file. */
#define HAVE_SYS_SIGINFO_H 1

/* Define to 1 if you have the <sys/signal.h> header file. */
#define HAVE_SYS_SIGNAL_H 1

/* Define to 1 if you have the <sys/socket.h> header file. */
#define HAVE_SYS_SOCKET_H 1

/* Define to 1 if you have the <sys/statvfs.h> header file. */
#define HAVE_SYS_STATVFS_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/systeminfo.h> header file. */
#define HAVE_SYS_SYSTEMINFO_H 1

/* Define to 1 if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define to 1 if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define to 1 if you have the <sys/vfs.h> header file. */
#define HAVE_SYS_VFS_H 1

/* Define to 1 if you have the <sys/vnode.h> header file. */
#define HAVE_SYS_VNODE_H 1

/* Define to 1 if you have the <time.h> header file. */
#define HAVE_TIME_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define to 1 if you have the <X11/extensions/multibuf.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_MULTIBUF_H */

/* Define to 1 if you have the <X11/extensions/readdisplay.h> header file. */
#define HAVE_X11_EXTENSIONS_READDISPLAY_H 1

/* Define to 1 if you have the <X11/extensions/transovl.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_TRANSOVL_H */

/* Define to 1 if you have the <Xmu/Editres.h> header file. */
/* #undef HAVE_XMU_EDITRES_H */

/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* define if the class ostream has member function form */
/* #undef OSTREAM_FORM_OK */

/* Name of package */
#define PACKAGE "OpenCAS"

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT ""

/* Define to the full name of this package. */
#define PACKAGE_NAME ""

/* Define to the full name and version of this package. */
#define PACKAGE_STRING ""

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME ""

/* Define to the version of this package. */
#define PACKAGE_VERSION ""

/* Define if compiler has function prototypes */
#define PROTOTYPES 1

/* Define as the return type of signal handlers (int’ or void'). */
#define RETSIGTYPE void

/* define if the function semctl takes a value */
/* #undef SEMCTL_NO_REFERENCE */

/* define if the function semop takes a value */
/* #undef SEMOP_NO_REFERENCE */

/* define if semun has member __buf */
/* #undef SEMUN_BUF_DEFINED */

/* define if the union semun is in sys/sem.h */
#define SEMUN_DEFINED

/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define to 1 if your <sys/time.h> declares struct tm’. */
/* #undef TM_IN_SYS_TIME */

/* Version number of package */
#define VERSION “6.0DVP1”

/* Define to 1 if your processor stores words with the most significant byte
first (like Motorola and SPARC, unlike Intel and VAX). */
#define WORDS_BIGENDIAN 1

/* Define to 1 if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
/* # undef _ALL_SOURCE */
#endif

/* Define to unsigned' if <sys/types.h> does not define. */
/* #undef size_t */

/* End IRIX Part */

#elif IRIX64

/* Define to 1 if using alloca.c’. */
/* #undef C_ALLOCA */

/* define if the compiler allows redefinition of stream input and output */
/* #undef DEF_IOS_OK */

/* Define to 1 if you have alloca', as a function or macro. */
#define HAVE_ALLOCA 1

/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#define HAVE_ALLOCA_H 1

/* Define to 1 if you have the <bits/sigset.h> header file. */
/* #undef HAVE_BITS_SIGSET_H */

/* Define to 1 if you have the <bstring.h> header file. */
#define HAVE_BSTRING_H 1

/* Define to 1 if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <dl.h> header file. */
/* #undef HAVE_DL_H */

/* Define to 1 if you have the <DPS/dpsXclient.h> header file. */
/* #undef HAVE_DPS_DPSXCLIENT_H */

/* Define if we have a function called "finite" in -lm. */
#define HAVE_FINITE

/* Define to 1 if you have the <floatingpoint.h> header file. */
/* #undef HAVE_FLOATINGPOINT_H */

/* Define to 1 if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1

/* Define to 1 if you have the <fstream> header file. */
#define HAVE_FSTREAM 1

/* Define to 1 if you have the <fstream.h> header file. */
#define HAVE_FSTREAM 1

/* Define to 1 if you have the gethostname’ function. */
#define HAVE_GETHOSTNAME 1

/* Define to 1 if you have the <getopt.h> header file. */
#define HAVE_GETOPT_H 1

/* Define to 1 if you have the <ieeefp.h> header file. */
#define HAVE_IEEEFP_H 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <iomanip> header file. */
#define HAVE_IOMANIP 1

/* Define to 1 if you have the <iomanip.h> header file. */
#define HAVE_IOMANIP 1

/* Define to 1 if you have the <ios> header file. */
#define HAVE_IOS 1

/* Define to 1 if you have the <iostream> header file. */
#define HAVE_IOSTREAM 1

/* Define to 1 if you have the <iostream.h> header file. */
#define HAVE_IOSTREAM 1

/* Define to 1 if you have the <ios.h> header file. */
/* #undef HAVE_IOS_H */

/* Define to 1 if you have the <istream> header file. */
#define HAVE_ISTREAM 1

/* Define to 1 if you have the <istream.h> header file. */
/* #undef HAVE_ISTREAM_H */

/* Define to 1 if you have the <libc.h> header file. */
#define HAVE_LIBC_H 1

/* Define to 1 if you have the e' library (-le). */
/* #undef HAVE_LIBE */

/* Define to 1 if you have the inks’ library (-links). */
/* #undef HAVE_LIBINKS */

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define if we have a function called “mallinfo” in -lmalloc. */
#define HAVE_MALLINFO

/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <ndir.h> header file. */
/* #undef HAVE_NDIR_H */

/* Define to 1 if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define to 1 if you have the <net/if.h> header file. */
#define HAVE_NET_IF_H 1

/* Define to 1 if you have the <osfcn.h> header file. */
/* #undef HAVE_OSFCN_H */

/* Define to 1 if you have the <ostream> header file. */
#define HAVE_OSTREAM 1

/* Define to 1 if you have the <ostream.h> header file. */
/* #undef HAVE_OSTREAM_H */

/* Define to 1 if you have the putenv' function. */
/* #undef HAVE_PUTENV */

/* Define to 1 if you have the <pwd.h> header file. */
#define HAVE_PWD_H 1

/* Define to 1 if you have the regcomp’ function. */
#define HAVE_REGCOMP 1

/* Define to 1 if you have the re_comp' function. */
#define HAVE_RE_COMP 1

/* Define to 1 if you have the <sigfpe.h> header file. */
#define HAVE_SIGFPE_H 1

/* Define to 1 if you have the <siginfo.h> header file. */
#define HAVE_SIGINFO_H 1

/* Define to 1 if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define to 1 if you have the statfs’ function. */
#define HAVE_STATFS 1

/* Define to 1 if you have the statvfs' function. */
#define HAVE_STATVFS 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the strcspn’ function. */
#define HAVE_STRCSPN 1

/* Define to 1 if you have the strdup' function. */
#define HAVE_STRDUP 1

/* Define to 1 if you have the <stream.h> header file. */
#define HAVE_STREAM_H 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <strstream.h> header file. */
#define HAVE_STRSTREAM_H 1

/* Define to 1 if you have the strtol’ function. */
/* #undef HAVE_STRTOL */

/* Define if we have a function called “ieee_handler” in -lsunmath. */
/* #undef HAVE_SUNMATH */

/* Define to 1 if you have the <sysent.h> header file. */
/* #undef HAVE_SYSENT_H */

/* Define to 1 if you have the <sys/dir.h> header file. */
#define HAVE_SYS_DIR_H 1

/* Define to 1 if you have the <sys/filio.h> header file. */
#define HAVE_SYS_FILIO_H 1

/* Define to 1 if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* Define to 1 if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define to 1 if you have the <sys/machsig.h> header file. */
/* #undef HAVE_SYS_MACHSIG_H */

/* Define to 1 if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define to 1 if you have the <sys/ndir.h> header file. */
/* #undef HAVE_SYS_NDIR_H */

/* Define to 1 if you have the <sys/param.h> header file. */
#define HAVE_SYS_PARAM_H 1

/* Define to 1 if you have the <sys/select.h> header file. */
#define HAVE_SYS_SELECT_H 1

/* Define to 1 if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define to 1 if you have the <sys/siginfo.h> header file. */
#define HAVE_SYS_SIGINFO_H 1

/* Define to 1 if you have the <sys/signal.h> header file. */
#define HAVE_SYS_SIGNAL_H 1

/* Define to 1 if you have the <sys/socket.h> header file. */
#define HAVE_SYS_SOCKET_H 1

/* Define to 1 if you have the <sys/statvfs.h> header file. */
#define HAVE_SYS_STATVFS_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/systeminfo.h> header file. */
#define HAVE_SYS_SYSTEMINFO_H 1

/* Define to 1 if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define to 1 if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define to 1 if you have the <sys/vfs.h> header file. */
#define HAVE_SYS_VFS_H 1

/* Define to 1 if you have the <sys/vnode.h> header file. */
#define HAVE_SYS_VNODE_H 1

/* Define to 1 if you have the <time.h> header file. */
#define HAVE_TIME_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define to 1 if you have the <X11/extensions/multibuf.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_MULTIBUF_H */

/* Define to 1 if you have the <X11/extensions/readdisplay.h> header file. */
#define HAVE_X11_EXTENSIONS_READDISPLAY_H 1

/* Define to 1 if you have the <X11/extensions/transovl.h> header file. */
/* #undef HAVE_X11_EXTENSIONS_TRANSOVL_H */

/* Define to 1 if you have the <Xmu/Editres.h> header file. */
/* #undef HAVE_XMU_EDITRES_H */

/* Define to 1 if your C compiler doesn’t accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* define if the class ostream has member function form */
/* #undef OSTREAM_FORM_OK */

/* Name of package */
#define PACKAGE “OpenCAS”

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT “”

/* Define to the full name of this package. */
#define PACKAGE_NAME “”

/* Define to the full name and version of this package. */
#define PACKAGE_STRING “”

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME “”

/* Define to the version of this package. */
#define PACKAGE_VERSION “”

/* Define if compiler has function prototypes */
#define PROTOTYPES 1

/* Define as the return type of signal handlers (int' or void’). */
#define RETSIGTYPE void

/* define if the function semctl takes a value */
/* #undef SEMCTL_NO_REFERENCE */

/* define if the function semop takes a value */
/* #undef SEMOP_NO_REFERENCE */

/* define if semun has member __buf */
/* #undef SEMUN_BUF_DEFINED */

/* define if the union semun is in sys/sem.h */
#define SEMUN_DEFINED

/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Define to 1 if your <sys/time.h> declares struct tm'. */
/* #undef TM_IN_SYS_TIME */

/* Version number of package */
#define VERSION "6.0DVP1"

/* Define to 1 if your processor stores words with the most significant byte
first (like Motorola and SPARC, unlike Intel and VAX). */
#define WORDS_BIGENDIAN 1

/* Define to 1 if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
/* # undef _ALL_SOURCE */
#endif

/* Define to unsigned’ if <sys/types.h> does not define. */
/* #undef size_t */

/*———————————————————*/
/* This part is extracted from config.h generated on HPUX */
/*———————————————————*/

#elif HPUX

#define WORDS_BIGENDIAN 1

#define HAVE_FSTREAM_H 1

#define HAVE_IOSTREAM_H 1

#define HAVE_IOMANIP_H 1
#define HAVE_LIMITS_H 1
/* Define if you have the <dirent.h> header file. */
#define HAVE_DIRENT_H 1

/* Define if you have the <sys/utsname.h> header file. */
#define HAVE_SYS_UTSNAME_H 1

/* Define if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define if you have the <sys/unistd.h> header file. */
#define HAVE_SYS_UNISTD_H 1

/* Define if you have the <sys/ipc.h> header file. */
#define HAVE_SYS_IPC_H 1

/* Define if you have the <sys/sem.h> header file. */
#define HAVE_SYS_SEM_H 1

/* Define if you have the <sys/vfs.h> header file. */
#define HAVE_STATFS 1
#define HAVE_SYS_VFS_H 1

/* Define if you have the <sys/times.h> header file. */
#define HAVE_SYS_TIMES_H 1

/* Define if you have the <dl.h> header file. */
#define HAVE_DL_H

/* Define if you have the <netdb.h> header file. */
#define HAVE_NETDB_H 1

/* Define if you have the <sys/ioctl.h> header file. */
#define HAVE_SYS_IOCTL_H 1

/* End HPUX Part */

#endif

/*——————————————————— */
/*  */
/*——————————————————— */

#endif

(Experiment 3)Modifying the opencascade file, to try to eliminated the either or Error

3.0 /* EXPERIMENT 3.0 2008-07-26 REM OUT HAVE_LIMITS_H and see what happens
#define HAVE_LIMITS_H 1 */

result:

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$   g++ -I /opt/OpenCASCADE6.2.0/ros/inc MakeBottle.cxx
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:9,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Address.hxx:21,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:28,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_values.h:35:2: error: #error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_OStream.hxx:7,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:40,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Stream.hxx:19:2: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_OutOfRange.hxx:33,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.lxx:4,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.hxx:326,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Trsf.hxx:32,
from /opt/OpenCASCADE6.2.0/ros/inc/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_SStream.hxx:23:4: error: #error “check config.h file or compilation options: either HAVE_IOSTREAM or HAVE_IOSTREAM_H should be defined”
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Address.hxx:21,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:28,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:

Experiment 3.0.1  It appears that HAVE_LIMITS_H is defined in a bunch of places.  I rem’d them all out.  Here we go again

Experiment 3.0.2 It seems like HAVE_LIMITS is not defined.  I tried to define and rerun to see what happens.
Something is not making sense here….. There seems to be no affect at this point.
Here seems to be the code segment that’s triggering first error inStandard_values.h

#if defined(_MSC_VER) && !defined(WNT)
#error “Wrong compiler options has been detected. Add /DWNT option for proper compilation!!!!!”
#endif

#ifndef WNT
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef HAVE_LIMITS
# include <limits>
#elif defined (HAVE_LIMITS_H)
# include <limits.h>
#else
#error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
#endif
#endif

Hm.. I need to research this a little more….

I ran across this on the OCC website.
http://www.opencascade.com/pub/doc/Release_Notes_6.1.pdf

“2. In order to exclude the possibility of collisions between the $CASROOT/inc/config.h file supplied with binary distribution and the $CASROOT/config.h file generated by configure script, a step of creation of a symbolic link between $CASROOT/inc/config.h and $CASROOT/config.h has been added to the configure script, so if the user executes configuration the $CASROOT/inc/config.h file supplied with binary distribution will be replaced by the generated one.”

It looks like I was messing with symlink and I didn’t realize it.  Although these notes where for 6.1,  My gut tells me 6.2 is slightly different. Either that or I really hosed something.
I’m trying another experiment.
I just ran ./configure in the /opt/OpenCASCADE6.2.0/ros subdirectory.   I just tried DRAWEXE it doesn’t work anymore from any Directory(another think to worry about)
I’m going rename my handy work than then symlink it to the $CASROOT/inc/config.h and see what happens.
I googled part of my error message and found to suggestion to try this.

jonas@Ubuntu4:/opt/OpenCASCADE6.2.0/samples/tutorial/src$ g++ -I /opt/OpenCASCADE6.2.0/ros/inc -DHAVE_IOSTREAM -DHAVE_LIMITS MakeBottle.cxx
In file included from /opt/OpenCASCADE6.2.0/ros/inc/Standard_Address.hxx:21,
from /opt/OpenCASCADE6.2.0/ros/inc/Standard.hxx:28,
from /opt/OpenCASCADE6.2.0/ros/inc/Handle_Geom_Surface.hxx:29,
from /opt/OpenCASCADE6.2.0/ros/inc/BRep_Tool.hxx:29,
from MakeBottle.cxx:1:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerFirst()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:129: error: ‘INT_MIN’ was not declared in this scope
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerLast()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:135: error: ‘INT_MAX’ was not declared in this scope
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx: In function ‘Standard_Integer IntegerSize()’:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx:141: error: ‘CHAR_BIT’ was not declared in this scope
In file included from /opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.hxx:326,
from /opt/OpenCASCADE6.2.0/ros/inc/gp_Trsf.hxx:32,
from /opt/OpenCASCADE6.2.0/ros/inc/BRepBuilderAPI_Transform.hxx:26,
from MakeBottle.cxx:8:
/opt/OpenCASCADE6.2.0/ros/inc/gp_Mat.lxx: In member function ‘void gp_Mat::SetValue(Standard_Integer, Standard_Integer, Standa…….. more

This is strange since, I’m not seeing this error pop up when I google this. Perhaps this is something that so elementary, that people just fix it?? It appears that #include tripped out the error….
In Standard_Address.hxx
Searching reveals:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_Integer.hxx
/opt/OpenCASCADE6.2.0/ros/src/Standard/Standard_Integer.hxx

Contents of Standard_integer.hxx reveals:

#ifndef _Standard_Integer_HeaderFile
#define _Standard_Integer_HeaderFile#ifndef _Standard_TypeDef_HeaderFile
#include <Standard_TypeDef.hxx>
#endif#ifndef _Standard_values_HeaderFile
# include <Standard_values.h>
#endifclass Handle_Standard_Type;__Standard_API Handle_Standard_Type& Standard_Integer_Type_();
// ===============================================
// Methods from Standard_Entity class which are redefined:
//    – Hascode
//    – IsEqual
//    – IsSimilar
//    – Shallowcopy
//    – ShallowDump
// ===============================================// ==================================
// Methods implemeted in Standard_Integer.cxx
// ==================================
__Standard_API Standard_Integer NextPrimeForMap(const Standard_Integer anInt ) ;
__Standard_API long             NextPrime   (const long               me);
__Standard_API Standard_Integer CharToInt   (const Standard_Character me);
__Standard_API Standard_Integer CharToInt   (const Standard_CString   me);
__Standard_API Standard_Integer ShallowCopy (const Standard_Integer   me);
//__Standard_API Standard_Integer HashCode    (const Standard_Integer, const Standard_Integer);// ===============
// Inline methods
// ===============// ——————————————————————
// Abs : Returns the absolute value of an Integer
// ——————————————————————
inline  Standard_Integer Abs (const Standard_Integer Value)
{
if ( Value >= 0 )
return Value;
else
return -Value;
}

// ——————————————————————
// Hascode : Computes a hascoding value for a given Integer
// ——————————————————————
inline Standard_Integer HashCode(const Standard_Integer me,
const Standard_Integer Upper)
{
//   return (Abs(me) % Upper) + 1;
return ( ( me & 0x7fffffff ) % Upper) + 1;
}

// ——————————————————————
// IsEqual : Returns Standard_True if two integers are equal
// ——————————————————————
inline Standard_Boolean IsEqual(const Standard_Integer One
,const Standard_Integer Two)
{ return One == Two; }

// ——————————————————————
// IsSimilar : Returns Standard_True if two integers are equal
// ——————————————————————
inline Standard_Boolean IsSimilar (const Standard_Integer One,
const Standard_Integer Two)
{ return One == Two; }

// ——————————————————————
// IsEven : Returns Standard_True if an integer is even
// ——————————————————————
inline Standard_Boolean IsEven (const Standard_Integer Value)
{ return Value % 2 == 0; }

// ——————————————————————
// IsOdd : Returns Standard_True if an integer is odd
// ——————————————————————
inline Standard_Boolean IsOdd (const Standard_Integer Value)
{ return Value % 2 == 1; }

// ——————————————————————
// Max : Returns the maximum integer between two integers
// ——————————————————————
inline Standard_Integer  Max (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 >= Val2)
return Val1;
else
return Val2;
}

// ——————————————————————
// Min : Returns the minimum integer between two integers
// ——————————————————————
inline Standard_Integer  Min (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 <= Val2)
return Val1;
else
return Val2;
}

// ——————————————————————
// Modulus : Returns the remainder of division between two integers
// ——————————————————————
inline Standard_Integer  Modulus (const Standard_Integer Value,
const Standard_Integer Divisor)
{ return Value % Divisor; }

// ——————————————————————
// Square : Returns the square of an integer
// ——————————————————————
inline Standard_Integer Square(const Standard_Integer Value)
{ return Value * Value; }

// ——————————————————————
// IntegerFirst : Returns the minimum value of an integer
// ——————————————————————
inline Standard_Integer  IntegerFirst()
{ return INT_MIN; }

// ——————————————————————
// IntegerLast : Returns the maximum value of an integer
// ——————————————————————
inline Standard_Integer  IntegerLast()
{ return  INT_MAX; }

// ——————————————————————
// IntegerSize : Returns the size in digits of an integer
// ——————————————————————
inline Standard_Integer  IntegerSize()
{ return (BITS(Standard_Integer)); }

#endif

Ok… My hypothesis is that this is something that got over looked when config.h was generated.
Also up to now, must of the error has been in C code this seem to be the first C++ code I’ve hit…
Hmmm. I’ve been reading Bruce Ekels’ thinking in C++.  I seem to recall a elementary program for return sizes…   C03:Specify.cpp

char= 1
unsigned char = 1
int = 4
unsigned int = 4
short = 2
unsigned short = 2
long = 4
unsigned long = 4
float = 4
double = 8
long double = 12

Well here’s the question do they mean min (negative)/ max value of a plain old int?
I guess we’ll try 32 bit which will cover my bases for int and long which is -2,147,483,648 to +2,147,483,647
This seems sort of silly that the code can’t figure this out, so I’m somewhat skeptical plopping
#define INT_MIN -2,147,483,648 into config.h is going to work… Hold on… I searched on this and it seems that INT_MIN is defined in limits.h??? So…. I suppose if I add this to MakeBottle.cxx this should take care of this… That makes sense….

Just out of curiosity, I’m going to do a quick search on limits.h and MakeBottle.cxx and see what pops up.  Nothing on that… Go figure.. Well adding limits.h to MakeBottle.cxx definately did something.  I need to redirect compiler output to a file now since so much text is being generated… More promising… I hope.

I just ran across this really cool link:http://www.codefighter.com/linux1.html when I was trying to figure out how to redirect   g++   (“>” doesn’t work “2>” does… ???)

It seems that the next most irritating thing is the “deprecated conversion from string constant to ‘char*’” message that pops up all over the place.  It sort of hides the trees from the forest.  I suppose its time to research that.
This is interesting:http://gcc.gnu.org/ml/gcc-help/2007-02/msg00078.htm

As is this:http://dilbert.physics.wm.edu/elog/Software/191
I guess I can ignore that for now, but sure is  irritating.
Ignoring that this seems to be the next issue.

/tmp/ccuDXf0A.o: In function MakeBottle(double, double, double)':
MakeBottle.cxx:(.text+0x31d): undefined reference to
GC_MakeArcOfCircle::GC_MakeArcOfCircle(gp_Pnt const&, gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x32f): undefined reference to GC_MakeArcOfCircle::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x35c): undefined reference to
GC_MakeSegment::GC_MakeSegment(gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x39b): undefined reference to GC_MakeSegment::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x3ec): undefined reference to
GC_MakeSegment::GC_MakeSegment(gp_Pnt const&, gp_Pnt const&)’
MakeBottle.cxx:(.text+0x3fe): undefined reference to GC_MakeSegment::operator Handle_Geom_TrimmedCurve() const'
MakeBottle.cxx:(.text+0x445): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x45d): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x4aa): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x4c2): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x50f): undefined reference to
BRepBuilderAPI_MakeEdge::BRepBuilderAPI_MakeEdge(Handle_Geom_Curve const&)’
MakeBottle.cxx:(.text+0x527): undefined reference to BRepBuilderAPI_MakeEdge::operator TopoDS_Edge() const'
MakeBottle.cxx:(.text+0x58b): undefined reference to
BRepBuilderAPI_MakeWire::BRepBuilderAPI_MakeWire(TopoDS_Edge const&, TopoDS_Edge const&, TopoDS_Edge const&)’

I wonder where that is…. I suspect I can fix this with -I statement.
It looks like it can find #include <GC_MakeArcOfCircle.hxx>
That’s strange since this is where its located:
/opt/OpenCASCADE6.2.0/ros/inc/GC_MakeArcOfCircle.hxx
and my current compiler string is:
g++ -I /opt/OpenCASCADE6.2.0/ros/inc -DHAVE_IOSTREAM -DHAVE_LIMITS MakeBottle.cxx 2> MakeBottle.errors
I guess I need to delve into GC_MakeArcOfCircle.hxx.   I looked into the header references so they all seem to be covered by the -I /opt/OpenCASCADE6.2.0/ros/inc so I’m barking up the wrong tree here….
My five year old want to play, so…. that it for now folks….
OK. I’m back I was just thinking.  I’m thinking that I shouldn’t have added that limits.h to the MakeBottle.cxx file.   I should realized that the original file had the HAVE_LIMITS AND HAVE_LIMIT_H constants in them that seem to have been deleted when I ran ./configure.

Experiment: remove -DHAVE_LIMITS from compiler string.
this resulted in the following error:
/opt/OpenCASCADE6.2.0/ros/inc/Standard_values.h:35:2: error: #error “check config.h file or compilation options: either HAVE_LIMITS or HAVE_LIMITS_H should be defined”
Back to config.h Need to search for the occurence of HAVE_LIMITS and HAVE_LIMITS_H.
Have HAVE_LIMITS_H is defined.  This is bizare. I think some how the HAVE_LIMITS somewhere other than config.h.

Experiment: remove _DHAVE_LIMITS from compile string and delete #include <limits.h> from MakeBottle.cxx
This seems to generate an error where I think it shouldn’t.  This is most strange.  I wonder how config.h if loaded by the compiler.
Experiment just for snicks and grins I want to see what happens if I include config.h in MakeBottle.cxx  Ok….  I wonder if this is a question for the forum.
I think I’ll leave #include config.h in MakeBottle.cxx for now.
These leave the current error as:

MakeBottle.cxx:(.text+0x31d): undefined reference to GC_MakeArcOfCircle::GC_MakeArcOfCircle(gp_Pnt const&, gp_Pnt const&, gp_Pnt const&)'
MakeBottle.cxx:(.text+0x32f): undefined reference to
GC_MakeArcOfCircle::operator Handle_Geom_TrimmedCurve() const’
MakeBottle.cxx:(.text+0x35c): undefined reference to GC_MakeSegment::GC_MakeSegment(gp_Pnt const&, gp_Pnt const&)'
MakeBottle.cxx:(.text+0x39b): undefined reference to
GC_MakeSegment::operator Handle_Geom_TrimmedCurve() const’
Ma
……………

This requires a little thought.
I think I probably need need a reference to where the libraries are.  The file structure is specified here:http://www.opencascade.org/org/gettingstarted/install/lunix

Experiment: add ros/lin to the compiler string.

This didn’t do anything.   I ran across the DRAWEXE executable.  I had it originally setup to execute from any directory.  It stopped working after I ran ./CONFIGURE  I thought was a minor glitch with the path getting overwritten or something.  I just tried running it directly and it won’t fire up….  EECCCH. I think I may have  really hosed something up…  Are we having fun yet?????

Posted in Uncategorized | Tagged , , | 1 Comment

Frustration Alley

Ok…
I just want to get the sound on Maelstrom running properly.  This thing is starting to make my brain ache.

The sound in Maelstrom is controlled via the SDL.  I posted some questions on the ubuntuforums and haven’t gotten any solutions yet. 🙁    I got Anjuta to load up the project and I think I isolated the code that controls the sound.  Unfortunately, its a little bit beyond me at this point.  I just need to keep hammering away.  Sound other than for my games is more of distraction to me rather than a primary interest.  Hopefully I’ll have an aha moment. And it will all come together.  It sort of irks me that I’ve been 3 hours of premium Sunday morning quiet time on this.

One to some other topics that don’t really give me brain cramps, I been really intrigued by the data-structures of the wordpress blog.  I’ve been looking at the mysql data-structure for the “settings” and been meaning to look at the php script that interacts with it.  I’m dealing with some applications at work, where this sort of thing might be useful.

Oh…. so much for the quite time… the dogs are barking, the five year old is up and heading this way….

Posted in Uncategorized | Leave a comment

Compiling Maelstrom from source for Ubuntu Linux

I really enjoy Maelstrom the game.  Somehow when I installed 8.04 on PC on my  P4V8X-MX motherboard I could never get the sound to on the game to work quite right. The sound would play int the background, but there was this irritating buzzing noise in the forground.  Most of my other application appear to work properly.  I posted a couple of times on Ubuntu and tried emailing the guy who created the package for linux with no response.   Soo….. I thought I would try to see if compiling it from source would take care of the problem… Or perhaps, I could try could isolate the code section and figure out what to do.
Either way it should be a learning experience.
I could swear there’s a way of downloading source from synaptic.   I poked around for a while and couldn’t find it.  I prefer getting my source from the repository, so I wanted to use apt-get.

I found some pretty good information here: http://www.debian.org/doc/manuals/apt-howto/ch-sourcehandling.en.html
I had tried to do the download and build the first time around and ran into some errors (plus it was really late and I was tired, so I wasn’t paying too close attention).  Instead of trying everything in one fell swoop, I thought I tried doing this a step at a time.

jonas@Ubuntu4:~$ apt-get source maelstrom
Reading package lists… Done
Building dependency tree
Reading state information… Done
Need to get 1094kB of source archives.
Get:1 http://us.archive.ubuntu.com hardy/multiverse maelstrom 1.4.3-L3.0.6-7ubuntu1 (dsc) [742B]
Get:2 http://us.archive.ubuntu.com hardy/multiverse maelstrom 1.4.3-L3.0.6-7ubuntu1 (tar) [976kB]
Get:3 http://us.archive.ubuntu.com hardy/multiverse maelstrom 1.4.3-L3.0.6-7ubuntu1 (diff) [116kB]
Fetched 1094kB in 16s (65.4kB/s)
gpg: Signature made Thu 05 Jul 2007 03:03:36 AM CDT using DSA key ID 7C8478FC
gpg: Can’t check signature: public key not found
dpkg-source: extracting maelstrom in maelstrom-1.4.3-L3.0.6
dpkg-source: unpacking maelstrom_1.4.3-L3.0.6.orig.tar.gz
dpkg-source: applying ./maelstrom_1.4.3-L3.0.6-7ubuntu1.diff.gz
jonas@Ubuntu4:~$ ls maelstrom*
maelstrom_1.4.3-L3.0.6-7ubuntu1.diff.gz  maelstrom_1.4.3-L3.0.6-7ubuntu1.dsc  maelstrom_1.4.3-L3.0.6.orig.tar.gz

maelstrom-1.4.3-L3.0.6:
acinclude.m4  configure     Docs          load.cpp             Maelstrom.spec     myerror.h        rect.h
aclocal.m4    configure.in  fastrand.cpp  load.h               Maelstrom.spec.in  netlogic         scores.cpp
autogen.sh    controls.cpp  fastrand.h    logic.h              Maelstrom_Sprites  netscore.cpp     scores.h
buttonlist.h  controls.h    icon.bmp      maclib               main.cpp           netscore.h       screenlib
Changelog     COPYING       icon.xpm      Maelstrom_Fonts      Makefile.am        public_key.h     sprintf.list
checksum.cpp  COPYING.GPL   ico_o         Maelstrom_Globals.h  Makefile.in        README
checksum.h    CREDITS       Images        Maelstrom.h          missing            README.joystick
colortable.h  debian        init.cpp      Maelstrom-netd.c     mkinstalldirs      README.network
config.guess  dialog.cpp    INSTALL       Maelstrom-Scores     MPWmake.sea.bin    README.options
config.sub    dialog.h      install-sh    Maelstrom_Sounds     myerror.cpp        rect.cpp
jonas@Ubuntu4:~$

Ok… so I have the source….
before the next step make sure you have fakeroot installed via synaptic
If I understand the instructions from the link above I need to do the following to build a deb package.

jonas@Ubuntu4:~$ cd maelstrom-1.4.3-L3.0.6
jonas@Ubuntu4:~/maelstrom-1.4.3-L3.0.6$ dpkg-buildpackage -rfakeroot -uc -b
dpkg-buildpackage: set CPPFLAGS to default value:
dpkg-buildpackage: set CFLAGS to default value: -g -O2
dpkg-buildpackage: set CXXFLAGS to default value: -g -O2
dpkg-buildpackage: set FFLAGS to default value: -g -O2
dpkg-buildpackage: set LDFLAGS to default value: -Wl,-Bsymbolic-functions
dpkg-buildpackage: source package maelstrom
dpkg-buildpackage: source version 1.4.3-L3.0.6-7ubuntu1
dpkg-buildpackage: source changed by Andrea Veri <bluekuja@ubuntu.com>
dpkg-buildpackage: host architecture i386
dpkg-checkbuilddeps: Unmet build dependencies: libsdl1.2-dev (>= 1.0.0) libsdl-net1.2-dev autotools-dev
dpkg-buildpackage: warning: Build dependencies/conflicts unsatisfied; aborting.
dpkg-buildpackage: warning: (Use -d flag to override.)
jonas@Ubuntu4:~/maelstrom-1.4.3-L3.0.6$

Ok… So I got some complaints about unmet dependancies.  So I went to synaptic and searched and downloaded the following:
libsdl1.2-dev
libsdl-net1.2-dev
autotools-dev

Lets try it again….  Apparently dpkg-buildpackage -rfakeroot -uc -b worked this time and created a deb package.  You can double click this from the file browser or from the the terminal:

jonas@Ubuntu4:~$ ls *.deb
maelstrom_1.4.3-L3.0.6-7ubuntu1_i386.deb
jonas@Ubuntu4:~$ sudo dpkg -i maelstrom_1.4.3-L3.0.6-7ubuntu1_i386.deb
Selecting previously deselected package maelstrom.
(Reading database … 162949 files and directories currently installed.)
Unpacking maelstrom (from maelstrom_1.4.3-L3.0.6-7ubuntu1_i386.deb) …
Setting up maelstrom (1.4.3-L3.0.6-7ubuntu1) …
installing debian default score file…

jonas@Ubuntu4:~$

I was hoping recompiling the program from source would automatically take care of the problem…. It didn’t…. I’m going to need to dig further.  My suspicion is that the code is fine, but there’s something messed up with my sound drivers…   Maybe time to dig into the source to figure out what’s going on.

Posted in C++ | Leave a comment

Export the 1&1 blog into your own wordpress blog that you create.

Ok… I just got done export porting my data from my old 1&1 blog and Imported into the wordpress log I just created.  I developed a set of step by step instructions on how to do this.  I’m a little bit tired at the moment so I don’t know if I forgot to save my draft or if my draft got deleted when I did the import.  @#%$

First off here is a good set of procedures to setup your very own wordpress blog.
The procedure for exporting the 1&1 blog and importing into wordpress is actually pretty easy and straight forward.

  1. Go into the 1&1 dash board
  2. Select the Administration tag.
  3. Under website builder select 1&1 blog
  4. Click on ‘Launch”
  5. On the blog you wish to export click on the Launch button
  6. Save to your desktop on your computer.

The file which downloaded as wordpress.2008-07-05.xml contains the rest of instructions which I have reprinted below:
<?xml version=”1.0″ encoding=”UTF-8″?>

<!–
This is a WordPress eXtended RSS file generated by WordPress as an export of
your blog. It contains information about your blog’s posts, comments, and
categories. You may use this file to transfer that content from one site to
another. This file is not intended to serve as a complete backup of your
blog.

To import this information into a WordPress blog follow these steps:

1.    Log into that blog as an administrator.
2.    Go to Manage > Import in the blog’s admin.
3.    Choose “WordPress” from the list of importers.
4.    Upload this file using the form provided on that page.
5.    You will first be asked to map the authors in this export file to users
on the blog. For each author, you may choose to map an existing user on
the blog or to create a new user.
6.    WordPress will then import each of the posts, comments, and categories
contained in this file onto your
blog.

All in all this was alot easier than my current studies in  C++
Goodnight…. 😉

Posted in Uncategorized | Tagged | 2 Comments

Hasta la vista baby

I was using the out of the can 1&1 blog and found it no longer met my needs.
I now blogging directly from www.metalshaperman.com instead of www.blog.metalshaperman.com
I’m leaving this sight up for now. I thought I couldn’t export my posts, but there is a way as you will see.

Posted in Uncategorized | Tagged | Leave a comment

Working on the theme

The original networker-10 out of the box

OK,,, I’m really starting to diverge from the path here……. But this plain blue is just not me….
I found some interesting information on themes:…http://codex.wordpress.org/Using_Themes/Theme_List
I thinking I’m going to be sticking to stuff of the WordPress site instead of looking for third party sites for clever add-on until I get to a point when I feel comfortable with what I’m doing..
The wordpress site points into a how to video tutorial: http://www.village-idiot.org/archives/2008/06/13/how-to-upload-a-wordpress-theme/ (I’m not on one save wavelength so this didn’t work for me….)
But… I went to the WordPress download site.

The theme my wife helped me pick out this theme case networker-10 .  The irony of this is that I’ve visited the authors site….  Let’s see what I can’t do with this….
OK… I guess I should benchmark what this template originally looked like before I started modifying it.

Posted in OpenCascade, Uncategorized | Tagged | Leave a comment