void DlgRevolution::findShapes()
{
App::Document* activeDoc = App::GetApplication().getActiveDocument();
if (!activeDoc) return;
Gui::Document* activeGui = Gui::Application::Instance->getDocument(activeDoc);
std::vector<App::DocumentObject*> objs = activeDoc->getObjectsOfType
(Part::Feature::getClassTypeId());
for (std::vector<App::DocumentObject*>::iterator it = objs.begin(); it!=objs.end(); ++it) {
const TopoDS_Shape& shape = static_cast<Part::Feature*>(*it)->Shape.getValue();
if (shape.IsNull()) continue;
TopExp_Explorer xp;
xp.Init(shape,TopAbs_SOLID);
if (xp.More()) continue; // solids not allowed
xp.Init(shape,TopAbs_COMPSOLID);
if (xp.More()) continue; // compound solids not allowed
// So allowed are: vertex, edge, wire, face, shell and compound
QTreeWidgetItem* item = new QTreeWidgetItem(ui->treeWidget);
item->setText(0, QString::fromUtf8((*it)->Label.getValue()));
item->setData(0, Qt::UserRole, QString::fromAscii((*it)->getNameInDocument()));
Gui::ViewProvider* vp = activeGui->getViewProvider(*it);
if (vp) item->setIcon(0, vp->getIcon());
}
}
bool DlgExtrusion::canExtrude(const TopoDS_Shape& shape) const
{
if (shape.IsNull())
return false;
TopAbs_ShapeEnum type = shape.ShapeType();
if (type == TopAbs_VERTEX || type == TopAbs_EDGE ||
type == TopAbs_WIRE || type == TopAbs_FACE ||
type == TopAbs_SHELL)
return true;
if (type == TopAbs_COMPOUND) {
TopExp_Explorer xp;
xp.Init(shape,TopAbs_SOLID);
while (xp.More()) {
return false;
}
xp.Init(shape,TopAbs_COMPSOLID);
while (xp.More()) {
return false;
}
return true;
}
return false;
}
void PovTools::writeShapeCSV(const char *FileName,
const TopoDS_Shape& Shape,
float fMeshDeviation,
float fLength)
{
const char cSeperator = ',';
Base::Console().Log("Meshing with Deviation: %f\n",fMeshDeviation);
TopExp_Explorer ex;
BRepMesh_IncrementalMesh MESH(Shape,fMeshDeviation);
// open the file and write
std::ofstream fout(FileName);
// counting faces and start sequencer
int l = 1;
for (ex.Init(Shape, TopAbs_FACE); ex.More(); ex.Next(),l++) {}
Base::SequencerLauncher seq("Writing file", l);
// write the file
l = 1;
for (ex.Init(Shape, TopAbs_FACE); ex.More(); ex.Next(),l++) {
// get the shape and mesh it
const TopoDS_Face& aFace = TopoDS::Face(ex.Current());
// this block mesh the face and transfers it in a C array of vertices and face indexes
Standard_Integer nbNodesInFace,nbTriInFace;
gp_Vec* vertices=0;
gp_Vec* vertexnormals=0;
long* cons=0;
transferToArray(aFace,&vertices,&vertexnormals,&cons,nbNodesInFace,nbTriInFace);
if (!vertices) break;
// writing per face header
// writing vertices
for (int i=0; i < nbNodesInFace; i++) {
fout << vertices[i].X() << cSeperator
<< vertices[i].Z() << cSeperator
<< vertices[i].Y() << cSeperator
<< vertexnormals[i].X() * fLength <<cSeperator
<< vertexnormals[i].Z() * fLength <<cSeperator
<< vertexnormals[i].Y() * fLength <<cSeperator
<< endl;
}
delete [] vertexnormals;
delete [] vertices;
delete [] cons;
seq.next();
} // end of face loop
fout.close();
}
FaceAdjacencySplitter::FaceAdjacencySplitter(const TopoDS_Shell &shell)
{
TopExp_Explorer shellIt;
for (shellIt.Init(shell, TopAbs_FACE); shellIt.More(); shellIt.Next())
{
TopTools_ListOfShape shapeList;
TopExp_Explorer it;
for (it.Init(shellIt.Current(), TopAbs_EDGE); it.More(); it.Next())
shapeList.Append(it.Current());
faceToEdgeMap.Add(shellIt.Current(), shapeList);
}
TopExp::MapShapesAndAncestors(shell, TopAbs_EDGE, TopAbs_FACE, edgeToFaceMap);
}
/**
* Writes out a vtk 2.0 file, currently hardcoded to c:\\outputcascade.vtk
*/
void OCGeometryRenderer::WriteVTK(TopoDS_Shape* out)
{
FILE *fp=fopen("C:\\outputcascade.vtk","w+");
fprintf(fp,"# vtk DataFile Version 2.0 \nOpenCascade data\nASCII\n");
fprintf(fp,"DATASET POLYDATA\n");
// BRepMesh::Mesh(out,0.1);
TopExp_Explorer Ex;
int countVert=0;
int countFace=0;
for(Ex.Init(*out,TopAbs_FACE);Ex.More();Ex.Next())
{
TopoDS_Face F=TopoDS::Face(Ex.Current());
TopLoc_Location L;
Handle (Poly_Triangulation) facing=BRep_Tool::Triangulation(F,L);
countVert+=facing->NbNodes();
countFace+=facing->NbTriangles();
}
fprintf(fp,"POINTS %d float\n",countVert);
for(Ex.Init(*out,TopAbs_FACE);Ex.More();Ex.Next())
{
TopoDS_Face F=TopoDS::Face(Ex.Current());
TopLoc_Location L;
Handle (Poly_Triangulation) facing=BRep_Tool::Triangulation(F,L);
TColgp_Array1OfPnt tab(1,(facing->NbNodes()));
tab = facing->Nodes();
for (Standard_Integer i=1;i<=(facing->NbNodes());i++) {
gp_Pnt pnt=tab.Value(i);
fprintf(fp,"%f %f %f\n",pnt.X(),pnt.Y(),pnt.Z());
}
}
fprintf(fp,"POLYGONS %d %d\n",countFace,countFace*4);
int maxindex=0;
for(Ex.Init(*out,TopAbs_FACE);Ex.More();Ex.Next())
{
TopoDS_Face F=TopoDS::Face(Ex.Current());
TopLoc_Location L;
Handle (Poly_Triangulation) facing=BRep_Tool::Triangulation(F,L);
TColgp_Array1OfPnt tab(1,(facing->NbNodes()));
tab = facing->Nodes();
Poly_Array1OfTriangle tri(1,facing->NbTriangles());
tri = facing->Triangles();
for (Standard_Integer i=1;i<=(facing->NbTriangles());i++) {
Poly_Triangle trian = tri.Value(i);
Standard_Integer index1,index2,index3;
trian.Get(index1,index2,index3);
fprintf(fp,"3 %d %d %d\n",maxindex+index1-1,maxindex+index2-1,maxindex+index3-1);
}
maxindex+=facing->NbNodes();
}
fclose(fp);
}
//=======================================================================
//function : GetEdgeOff
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_Tools3D::GetEdgeOff(const TopoDS_Edge& theE1,
const TopoDS_Face& theF2,
TopoDS_Edge& theE2)
{
Standard_Boolean bFound;
TopAbs_Orientation aOr1, aOr1C, aOr2;
TopExp_Explorer anExp;
//
bFound=Standard_False;
aOr1=theE1.Orientation();
aOr1C=TopAbs::Reverse(aOr1);
//
anExp.Init(theF2, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Edge& aEF2=TopoDS::Edge(anExp.Current());
if (aEF2.IsSame(theE1)) {
aOr2=aEF2.Orientation();
if (aOr2==aOr1C) {
theE2=aEF2;
bFound=!bFound;
return bFound;
}
}
}
return bFound;
}
std::vector<TopoDS_Wire> SketchBased::getSketchWires() const {
std::vector<TopoDS_Wire> result;
TopoDS_Shape shape = getVerifiedSketch()->Shape.getShape()._Shape;
if (shape.IsNull())
throw Base::Exception("Linked shape object is empty");
// this is a workaround for an obscure OCC bug which leads to empty tessellations
// for some faces. Making an explicit copy of the linked shape seems to fix it.
// The error almost happens when re-computing the shape but sometimes also for the
// first time
BRepBuilderAPI_Copy copy(shape);
shape = copy.Shape();
if (shape.IsNull())
throw Base::Exception("Linked shape object is empty");
TopExp_Explorer ex;
for (ex.Init(shape, TopAbs_WIRE); ex.More(); ex.Next()) {
result.push_back(TopoDS::Wire(ex.Current()));
}
if (result.empty()) // there can be several wires
throw Base::Exception("Linked shape object is not a wire");
return result;
}
//=======================================================================
//function : CorrectWires
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_Tools::CorrectWires(const TopoDS_Shape& aShape)
{
Standard_Boolean bRet;
TopoDS_Iterator aItF;
TopExp_Explorer aExp;
TopTools_MapOfShape aMF;
GeomAdaptor_Surface aGAS;
GeomAbs_SurfaceType aTS;
TopLoc_Location aLoc;
//
bRet=Standard_False;
//
aExp.Init(aShape, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face*)&aExp.Current());
if (aMF.Add(aF)) {
const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF, aLoc);
aGAS.Load(aS);
aTS=aGAS.GetType();
if (aTS==GeomAbs_Cylinder || aTS==GeomAbs_Plane) {
aItF.Initialize(aF);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Wire& aW=*((TopoDS_Wire*)&aItF.Value());
if (CorrectWire(aW, aF)) {
bRet=Standard_True;
}
}
}
}
}
return bRet;
}
//added by tanderson. aka blobfish.
//projection algorithms build a 2d curve(pcurve) but no 3d curve.
//this causes problems with meshing algorithms after save and load.
static const TopoDS_Shape& build3dCurves(const TopoDS_Shape &shape)
{
TopExp_Explorer it;
for (it.Init(shape, TopAbs_EDGE); it.More(); it.Next())
BRepLib::BuildCurve3d(TopoDS::Edge(it.Current()));
return shape;
}
void TaskCheckGeometryResults::checkSub(const BRepCheck_Analyzer &shapeCheck, const TopoDS_Shape &shape,
const TopAbs_ShapeEnum subType, ResultEntry *parent)
{
BRepCheck_ListIteratorOfListOfStatus itl;
TopExp_Explorer exp;
for (exp.Init(shape,subType); exp.More(); exp.Next())
{
const Handle(BRepCheck_Result)& res = shapeCheck.Result(exp.Current());
const TopoDS_Shape& sub = exp.Current();
for (res->InitContextIterator(); res->MoreShapeInContext(); res->NextShapeInContext())
{
if (res->ContextualShape().IsSame(shape))
{
for (itl.Initialize(res->StatusOnShape()); itl.More(); itl.Next())
{
if (itl.Value() == BRepCheck_NoError)
break;
checkedMap.Add(sub);
ResultEntry *entry = new ResultEntry();
entry->parent = parent;
entry->shape = sub;
entry->buildEntryName();
entry->type = shapeEnumToString(sub.ShapeType());
entry->error = checkStatusToString(itl.Value());
entry->viewProviderRoot = currentSeparator;
entry->viewProviderRoot->ref();
dispatchError(entry, itl.Value());
parent->children.push_back(entry);
}
}
}
}
}
void PartGui::goSetupResultTypedSelection(ResultEntry* entry, const TopoDS_Shape& shape, TopAbs_ShapeEnum type)
{
TopExp_Explorer it;
for (it.Init(shape, type); it.More(); it.Next())
{
QString name = buildSelectionName(entry, (it.Current()));
if (!name.isEmpty())
entry->selectionStrings.append(name);
}
}
void CmdPartDesignPad::activated(int iMsg)
{
unsigned int n = getSelection().countObjectsOfType(Part::Part2DObject::getClassTypeId());
if (n != 1) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong selection"),
QObject::tr("Select a sketch or 2D object."));
return;
}
std::string FeatName = getUniqueObjectName("Pad");
std::vector<App::DocumentObject*> Sel = getSelection().getObjectsOfType(Part::Part2DObject::getClassTypeId());
Part::Part2DObject* sketch = static_cast<Part::Part2DObject*>(Sel.front());
const TopoDS_Shape& shape = sketch->Shape.getValue();
if (shape.IsNull()) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong selection"),
QObject::tr("The shape of the selected object is empty."));
return;
}
// count free wires
int ctWires=0;
TopExp_Explorer ex;
for (ex.Init(shape, TopAbs_WIRE); ex.More(); ex.Next()) {
ctWires++;
}
if (ctWires == 0) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong selection"),
QObject::tr("The shape of the selected object is not a wire."));
return;
}
App::DocumentObject* support = sketch->Support.getValue();
openCommand("Make Pad");
doCommand(Doc,"App.activeDocument().addObject(\"PartDesign::Pad\",\"%s\")",FeatName.c_str());
doCommand(Doc,"App.activeDocument().%s.Sketch = App.activeDocument().%s",FeatName.c_str(),sketch->getNameInDocument());
doCommand(Doc,"App.activeDocument().%s.Length = 10.0",FeatName.c_str());
updateActive();
if (isActiveObjectValid()) {
doCommand(Gui,"Gui.activeDocument().hide(\"%s\")",sketch->getNameInDocument());
if (support)
doCommand(Gui,"Gui.activeDocument().hide(\"%s\")",support->getNameInDocument());
}
doCommand(Gui,"Gui.activeDocument().setEdit('%s')",FeatName.c_str());
//commitCommand();
adjustCameraPosition();
if (support) {
copyVisual(FeatName.c_str(), "ShapeColor", support->getNameInDocument());
copyVisual(FeatName.c_str(), "LineColor", support->getNameInDocument());
copyVisual(FeatName.c_str(), "PointColor", support->getNameInDocument());
}
}
//=======================================================================
// function: Sense
// purpose:
//=======================================================================
Standard_Integer GEOMAlgo_Tools3D::Sense (const TopoDS_Face& theF1,
const TopoDS_Face& theF2)
{
Standard_Integer iSense=0;
gp_Dir aDNF1, aDNF2;
TopoDS_Edge aE1, aE2;
TopExp_Explorer anExp;
//
anExp.Init(theF1, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
aE1=TopoDS::Edge(anExp.Current());
if (!BRep_Tool::Degenerated(aE1)) {
if (!BRep_Tool::IsClosed(aE1, theF1)) {
break;
}
}
}
//
anExp.Init(theF2, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
aE2=TopoDS::Edge(anExp.Current());
if (!BRep_Tool::Degenerated(aE2)) {
if (!BRep_Tool::IsClosed(aE2, theF2)) {
if (aE2.IsSame(aE1)) {
iSense=1;
break;
}
}
}
}
//
if (!iSense) {
return iSense;
}
//
BOPTools_Tools3D::GetNormalToFaceOnEdge(aE1, theF1, aDNF1);
BOPTools_Tools3D::GetNormalToFaceOnEdge(aE2, theF2, aDNF2);
//
iSense=BOPTools_Tools3D::SenseFlag(aDNF1, aDNF2);
//
return iSense;
}
TopoDS_Shape Feature::getSolid(const TopoDS_Shape& shape)
{
if (shape.IsNull())
Standard_Failure::Raise("Shape is null");
TopExp_Explorer xp;
xp.Init(shape,TopAbs_SOLID);
for (;xp.More(); xp.Next()) {
return xp.Current();
}
return TopoDS_Shape();
}
void Edgesort::Perform()
{
if ( m_shape.IsNull() )
return;
//adds all the vertices to a map, and store the associated edges
TopExp_Explorer explorer;
Standard_Integer nbEdges = 0;
Standard_Integer nbNonEdges = 0;
for ( explorer.Init(m_shape,TopAbs_EDGE) ; explorer.More() ; explorer.Next() )
{
const TopoDS_Edge& currentEdge = TopoDS::Edge(explorer.Current());
if (IsValidEdge(currentEdge))
{
Perform(currentEdge);
nbEdges++;
}
else
{
nbNonEdges++;
}
}
//now, iterate through the edges to sort them
do
{
m_edges.clear();
tMapPntEdge::iterator iter = m_vertices.begin();
const gp_Pnt& firstPoint = iter->first;
gp_Pnt currentPoint = firstPoint;
Standard_Boolean toContinue;
do
{
toContinue = PerformEdges(currentPoint);
}
while (toContinue == Standard_True);
tEdgeBBoxPair aTempPair;
aTempPair.first = getBoundingBox(m_edges);
aTempPair.second = m_edges;
m_EdgeBBoxMap.insert(aTempPair);
}
while (!m_vertices.empty());
m_done = true;
}
void FaceTypeSplitter::split()
{
TopExp_Explorer shellIt;
for (shellIt.Init(shell, TopAbs_FACE); shellIt.More(); shellIt.Next())
{
TopoDS_Face tempFace(TopoDS::Face(shellIt.Current()));
GeomAbs_SurfaceType currentType = FaceTypedBase::getFaceType(tempFace);
SplitMapType::iterator mapIt = typeMap.find(currentType);
if (mapIt == typeMap.end())
continue;
(*mapIt).second.push_back(tempFace);
}
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Add(const TopoDS_Shape& theShape,
const TopAbs_ShapeEnum theType)
{
TopExp_Explorer aExp;
//
aExp.Init(theShape, theType);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aS=aExp.Current();
if (myMap.Add(aS)) {
myList.Append(aS);
}
}
}
std::list<TopoDS_Wire> CrossSection::section(double d) const
{
std::list<TopoDS_Wire> wires;
BRepAlgoAPI_Section cs(s, gp_Pln(a,b,c,-d));
if (cs.IsDone()) {
std::list<TopoDS_Edge> edges;
TopExp_Explorer xp;
for (xp.Init(cs.Shape(), TopAbs_EDGE); xp.More(); xp.Next())
edges.push_back(TopoDS::Edge(xp.Current()));
connectEdges(edges, wires);
}
return wires;
}
bool Geometry::GetFaces(const TopoDS_Shape &brep, Geometry::FaceSet &faces) {
TopExp_Explorer Ex;
int count=0;
for (Ex.Init(brep,TopAbs_FACE); Ex.More(); Ex.Next()) {
faces.push_back(new TopoDS_Face);
faces.at(faces.size()-1)= TopoDS::Face(Ex.Current());
count++;
}
// if(count>=1)
// cout<<"element: has "<<boost::lexical_cast<string>(count)<<" faces"<<endl;
if(count < 1)
cout<<"error! no face is found in this building element"<<endl;
return count>0;
}
bool Geometry::GetShells(const TopoDS_Shape &brep, Geometry::ShellSet &shells) {
TopExp_Explorer Ex;
int count=0;
for (Ex.Init(brep,TopAbs_SHELL); Ex.More(); Ex.Next()) {
shells.push_back(new TopoDS_Shell);
shells.at(shells.size()-1)= TopoDS::Shell(Ex.Current());
count++;
}
// if(count>=1)
// cout<<"element: has "<<boost::lexical_cast<string>(count)<<" shells"<<endl;
if(count < 1)
cout<<"error! no shell is found in this building element"<<endl;
return count>0;
}
const gp_Pnt Feature::getPointFromFace(const TopoDS_Face& f)
{
if (!f.Infinite()) {
TopExp_Explorer exp;
exp.Init(f, TopAbs_VERTEX);
if (exp.More())
return BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()));
// Else try the other method
}
// TODO: Other method, e.g. intersect X,Y,Z axis with the (unlimited?) face?
// Or get a "corner" point if the face is limited?
throw Base::Exception("getPointFromFace(): Not implemented yet for this case");
}
void CurveProjectorShape::Do(void)
{
TopExp_Explorer Ex;
TopoDS_Shape Edge;
for (Ex.Init(_Shape, TopAbs_EDGE); Ex.More(); Ex.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(Ex.Current());
//std::vector<FaceSplitEdge> vSplitEdges;
projectCurve(aEdge, mvEdgeSplitPoints[aEdge]);
}
}
void MeshProjection::projectToMesh ( const TopoDS_Shape &aShape, float fMaxDist, std::vector<SplitEdge>& rSplitEdges ) const
{
// calculate the average edge length and create a grid
MeshAlgorithm clAlg( _rcMesh );
float fAvgLen = clAlg.GetAverageEdgeLength();
MeshFacetGrid cGrid( _rcMesh, 5.0f*fAvgLen );
TopExp_Explorer Ex;
TopoDS_Shape Edge;
int iCnt=0;
for (Ex.Init(aShape, TopAbs_EDGE); Ex.More(); Ex.Next())
iCnt++;
Base::Sequencer().start( "Project curve on mesh", iCnt );
for (Ex.Init(aShape, TopAbs_EDGE); Ex.More(); Ex.Next()) {
const TopoDS_Edge& aEdge = TopoDS::Edge(Ex.Current());
projectEdgeToEdge( aEdge, fMaxDist, cGrid, rSplitEdges );
Base::Sequencer().next();
}
Base::Sequencer().stop();
}
// Modified Thu Sep 14 14:35:18 2006
// Contribution of Samtech www.samcef.com BEGIN
//=======================================================================
//function : Contains
//purpose :
//=======================================================================
Standard_Boolean Contains(const TopoDS_Face& aF,
const TopoDS_Vertex& aV)
{
Standard_Boolean bRet;
TopExp_Explorer aExp;
//
bRet=Standard_False;
aExp.Init(aF, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aVF=aExp.Current();
if (aVF.IsSame(aV)) {
bRet=!bRet;
break;
}
}
return bRet;
}
int OCCWire::offset(double distance, int joinType = 0) {
Handle(TopTools_HSequenceOfShape) wires = new TopTools_HSequenceOfShape;
Handle(TopTools_HSequenceOfShape) edges = new TopTools_HSequenceOfShape;
TopExp_Explorer ex;
try {
GeomAbs_JoinType join = GeomAbs_Arc;
switch (joinType) {
case 1:
join = GeomAbs_Tangent;
break;
case 2:
join = GeomAbs_Intersection;
break;
}
BRepOffsetAPI_MakeOffset MO(this->getWire(), join);
MO.Perform(distance);
for (ex.Init(MO.Shape(), TopAbs_EDGE); ex.More(); ex.Next()) {
if (!ex.Current().IsNull()) {
edges->Append(TopoDS::Edge(ex.Current()));
}
}
ShapeAnalysis_FreeBounds::ConnectEdgesToWires(edges,Precision::Confusion(),Standard_True,wires);
if (wires->Length() != 1)
StdFail_NotDone::Raise("offset operation created empty result");
this->setShape(wires->Value(1));
// possible fix shape
if (!this->fixShape())
StdFail_NotDone::Raise("Shapes not valid");
} catch(Standard_Failure &err) {
Handle_Standard_Failure e = Standard_Failure::Caught();
const Standard_CString msg = e->GetMessageString();
if (msg != NULL && strlen(msg) > 1) {
setErrorMessage(msg);
} else {
setErrorMessage("Failed to offset wire");
}
return 0;
}
return 1;
}
bool GetBiggestSolid(TopoDS_Shape& solid)
{
TopExp_Explorer solidExp;
TopoDS_Shape aSolid;
double maxVolume = 0;
double volume;
for (solidExp.Init(solid,TopAbs_SOLID); solidExp.More(); solidExp.Next())
{
aSolid = solidExp.Current();
volume = GetVolume(aSolid);
if (maxVolume < volume)
{
maxVolume = volume;
solid = aSolid;
}
}
return true;
}
int extractShape(const TopoDS_Shape& shape, std::vector<OCCBase *>& shapes)
{
TopAbs_ShapeEnum type = shape.ShapeType();
if (type != TopAbs_COMPOUND) {
extractSubShape(shape, shapes);
return 0;
}
TopExp_Explorer ex;
int ret = 0;
// extract compund
for (ex.Init(shape, TopAbs_COMPOUND); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
// extract solids
for (ex.Init(shape, TopAbs_COMPSOLID); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
for (ex.Init(shape, TopAbs_SOLID); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
// extract free faces
for (ex.Init(shape, TopAbs_SHELL, TopAbs_SOLID); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
for (ex.Init(shape, TopAbs_FACE, TopAbs_SOLID); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
// extract free wires
for (ex.Init(shape, TopAbs_WIRE, TopAbs_FACE); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
// extract free edges
for (ex.Init(shape, TopAbs_EDGE, TopAbs_WIRE); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
// extract free vertices
for (ex.Init(shape, TopAbs_VERTEX, TopAbs_EDGE); ex.More(); ex.Next())
ret += extractSubShape(ex.Current(), shapes);
return ret;
}
void CurveProjectorSimple::Do(void)
{
TopExp_Explorer Ex;
TopoDS_Shape Edge;
std::vector<Base::Vector3f> vEdgePolygon;
for (Ex.Init(_Shape, TopAbs_EDGE); Ex.More(); Ex.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(Ex.Current());
// GetSampledCurves(aEdge,vEdgePolygon,2000);
//std::vector<FaceSplitEdge> vSplitEdges;
projectCurve(aEdge,vEdgePolygon, mvEdgeSplitPoints[aEdge]);
}
}
Standard_Boolean ViewProviderCurveNet::computeEdges(SoSeparator* root, const TopoDS_Shape &myShape)
{
unsigned long ulNbOfPoints = 50;
TopExp_Explorer ex;
SoSeparator *EdgeRoot = new SoSeparator();
root->addChild(EdgeRoot);
EdgeRoot->addChild(pcLineStyle);
EdgeRoot->addChild(pcLineMaterial);
for (ex.Init(myShape, TopAbs_EDGE); ex.More(); ex.Next())
{
// get the shape and mesh it
const TopoDS_Edge& aEdge = TopoDS::Edge(ex.Current());
Standard_Real fBegin, fEnd;
SbVec3f* vertices = new SbVec3f[ulNbOfPoints];
Handle(Geom_Curve) hCurve = BRep_Tool::Curve(aEdge,fBegin,fEnd);
float fLen = float(fEnd - fBegin);
for (unsigned long i = 0; i < ulNbOfPoints; i++)
{
gp_Pnt gpPt = hCurve->Value(fBegin + (fLen * float(i)) / float(ulNbOfPoints-1));
vertices[i].setValue((float)(gpPt.X()),(float)(gpPt.Y()),(float)(gpPt.Z()));
}
// define vertices
SoCoordinate3 * coords = new SoCoordinate3;
coords->point.setValues(0,ulNbOfPoints, vertices);
EdgeRoot->addChild(coords);
// define the indexed face set
SoLocateHighlight* h = new SoLocateHighlight();
h->color.setValue((float)0.2,(float)0.5,(float)0.2);
SoLineSet * lineset = new SoLineSet;
h->addChild(lineset);
EdgeRoot->addChild(h);
}
return true;
}
OCCMesh *OCCFace::createMesh(double factor, double angle, bool qualityNormals = true)
{
OCCMesh *mesh = new OCCMesh();
try {
Bnd_Box aBox;
BRepBndLib::Add(this->getShape(), aBox);
Standard_Real aXmin, aYmin, aZmin;
Standard_Real aXmax, aYmax, aZmax;
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
Standard_Real maxd = fabs(aXmax - aXmin);
maxd = std::max(maxd, fabs(aYmax - aYmin));
maxd = std::max(maxd, fabs(aZmax - aZmin));
BRepMesh_FastDiscret MSH(factor*maxd, angle, aBox, Standard_False, Standard_False,
Standard_True, Standard_True);
MSH.Perform(this->getShape());
BRepMesh_IncrementalMesh(this->getShape(),factor*maxd);
if (this->getShape().ShapeType() != TopAbs_FACE) {
TopExp_Explorer exFace;
for (exFace.Init(this->getShape(), TopAbs_FACE); exFace.More(); exFace.Next()) {
const TopoDS_Face& faceref = static_cast<const TopoDS_Face &>(exFace.Current());
mesh->extractFaceMesh(faceref, qualityNormals);
}
} else {
mesh->extractFaceMesh(this->getFace(), qualityNormals);
}
} catch(Standard_Failure &err) {
Handle_Standard_Failure e = Standard_Failure::Caught();
const Standard_CString msg = e->GetMessageString();
if (msg != NULL && strlen(msg) > 1) {
setErrorMessage(msg);
} else {
setErrorMessage("Failed to create mesh");
}
return NULL;
}
return mesh;
}