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;
}
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 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::fromLatin1((*it)->getNameInDocument()));
Gui::ViewProvider* vp = activeGui->getViewProvider(*it);
if (vp) item->setIcon(0, vp->getIcon());
}
}
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);
}
}
gp_Pnt GetCentralFacePoint(const TopoDS_Face& face)
{
// compute point on face
Standard_Real umin, umax, vmin, vmax;
gp_Pnt p;
Handle(Geom_Surface) surface = BRep_Tool::Surface(face);
BRepTools::UVBounds(face, umin, umax, vmin, vmax);
Standard_Real umean = 0.5*(umin+umax);
Standard_Real vmean = 0.5*(vmin+vmax);
// compute intersection of u-iso line with face boundaries
Handle(Geom2d_Curve) uiso = new Geom2d_Line(
gp_Pnt2d(umean,0.),
gp_Dir2d(0., 1.)
);
TopExp_Explorer exp (face,TopAbs_EDGE);
std::list<double> intersections;
for (; exp.More(); exp.Next()) {
TopoDS_Edge edge = TopoDS::Edge(exp.Current());
Standard_Real first, last;
// Get geomteric curve from edge
Handle(Geom2d_Curve) hcurve = BRep_Tool::CurveOnSurface(edge, face, first, last);
hcurve = new Geom2d_TrimmedCurve(hcurve, first, last);
Geom2dAPI_InterCurveCurve intersector(uiso, hcurve);
for (int ipoint = 0; ipoint < intersector.NbPoints(); ++ipoint) {
gp_Pnt2d p = intersector.Point(ipoint+1);
intersections.push_back(p.Y());
}
}
// remove duplicate solutions defined by tolerance
double tolerance = 1e-5;
intersections.sort();
intersections.unique(IsSame((vmax-vmin)*tolerance));
// normally we should have at least two intersections
// also the number of sections should be even - else something is really strange
//assert(intersections.size() % 2 == 0);
if (intersections.size() >= 2) {
std::list<double>::iterator it = intersections.begin();
double int1 = *it++;
double int2 = *it;
vmean = (int1 + int2)/2.;
}
surface->D0(umean, vmean, p);
return p;
}
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());
}
}
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();
}
const TopoDS_Shape& Feature::getBaseShape() const {
const Part::Feature* BaseObject = getBaseObject();
const TopoDS_Shape& result = BaseObject->Shape.getValue();
if (result.IsNull())
throw Base::Exception("Base feature's shape is invalid");
TopExp_Explorer xp (result, TopAbs_SOLID);
if (!xp.More())
throw Base::Exception("Base feature's shape is not a solid");
return result;
}
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");
}
const TopoDS_Shape& SketchBased::getSupportShape() const {
Part::Feature* SupportObject = getSupport();
if (SupportObject == NULL)
throw Base::Exception("No support in Sketch!");
const TopoDS_Shape& result = SupportObject->Shape.getValue();
if (result.IsNull())
throw Base::Exception("Support shape is invalid");
TopExp_Explorer xp (result, TopAbs_SOLID);
if (!xp.More())
throw Base::Exception("Support shape is not a solid");
return result;
}
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 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();
}
// 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;
}
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]);
}
}
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;
}
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;
}
SPC::TopoDS_Edge OccContactShape::edge(unsigned int index) const
{
SP::TopoDS_Edge return_value(new TopoDS_Edge());
TopExp_Explorer exp;
exp.Init(this->data(), TopAbs_EDGE);
for (unsigned int i=0; i<index; ++i, exp.Next());
if (exp.More())
{
// taking a ref fail!
*return_value = TopoDS::Edge(exp.Current());
}
else
{
RuntimeException::selfThrow("OccContactShape::edge failed");
}
return return_value;
}
void CurveProjectorWithToolMesh::Do(void)
{
TopExp_Explorer Ex;
TopoDS_Shape Edge;
std::vector<MeshGeomFacet> cVAry;
std::vector<Base::Vector3f> vEdgePolygon;
for (Ex.Init(_Shape, TopAbs_EDGE); Ex.More(); Ex.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(Ex.Current());
makeToolMesh(aEdge,cVAry);
}
ToolMesh.AddFacets(cVAry);
}
// constructor method
int TopoShapeSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
{
PyObject *obj;
if (!PyArg_ParseTuple(args, "O!", &(TopoShapePy::Type), &obj))
return -1;
try {
const TopoDS_Shape& shape = static_cast<TopoShapePy*>(obj)
->getTopoShapePtr()->getShape();
//first, if we were given a compsolid, try making a solid out of it
TopExp_Explorer CSExp (shape, TopAbs_COMPSOLID);
TopoDS_CompSolid compsolid;
int count=0;
for (; CSExp.More(); CSExp.Next()) {
++count;
compsolid = TopoDS::CompSolid(CSExp.Current());
if (count > 1)
break;
}
if (count == 0) {
//no compsolids. Get shells...
BRepBuilderAPI_MakeSolid mkSolid;
TopExp_Explorer anExp (shape, TopAbs_SHELL);
count=0;
for (; anExp.More(); anExp.Next()) {
++count;
mkSolid.Add(TopoDS::Shell(anExp.Current()));
}
if (count == 0)//no shells?
Standard_Failure::Raise("No shells or compsolids found in shape");
TopoDS_Solid solid = mkSolid.Solid();
BRepLib::OrientClosedSolid(solid);
getTopoShapePtr()->setShape(solid);
} else if (count == 1) {
BRepBuilderAPI_MakeSolid mkSolid(compsolid);
TopoDS_Solid solid = mkSolid.Solid();
getTopoShapePtr()->setShape(solid);
} else if (count > 1) {
Standard_Failure::Raise("Only one compsolid can be accepted. Provided shape has more than one compsolid.");
}
}
catch (Standard_Failure err) {
std::stringstream errmsg;
errmsg << "Creation of solid failed: " << err.GetMessageString();
PyErr_SetString(PartExceptionOCCError, errmsg.str().c_str());
return -1;
}
return 0;
}
/**
* @briefAdds a shape to the IGES file. All faces are named according to their face
* traits. If there are no faces, the wires are named according to the shape name.
*
* The level parameter defines the iges layer/level, which is another way of grouping faces.
*/
void CTiglExportIges::AddToIges(PNamedShape shape, IGESControl_Writer& writer, int level) const
{
if (!shape) {
return;
}
std::string shapeName = shape->Name();
std::string shapeShortName = shape->ShortName();
Handle(Transfer_FinderProcess) FP = writer.TransferProcess();
TopTools_IndexedMapOfShape faceMap;
TopExp::MapShapes(shape->Shape(), TopAbs_FACE, faceMap);
// any faces?
if (faceMap.Extent() > 0) {
int ret = writer.AddShape(shape->Shape());
if (ret > IFSelect_RetDone) {
throw CTiglError("Error: Export to IGES file failed in CTiglExportStep. Could not translate shape "
+ shapeName + " to iges entity,", TIGL_ERROR);
}
WriteIgesNames(FP, shape, level);
}
else {
// no faces, export edges as wires
Handle(TopTools_HSequenceOfShape) Edges = new TopTools_HSequenceOfShape();
TopExp_Explorer myEdgeExplorer (shape->Shape(), TopAbs_EDGE);
while (myEdgeExplorer.More()) {
Edges->Append(TopoDS::Edge(myEdgeExplorer.Current()));
myEdgeExplorer.Next();
}
ShapeAnalysis_FreeBounds::ConnectEdgesToWires(Edges, 1e-7, false, Edges);
for (int iwire = 1; iwire <= Edges->Length(); ++iwire) {
int ret = writer.AddShape(Edges->Value(iwire));
if (ret > IFSelect_RetDone) {
throw CTiglError("Error: Export to IGES file failed in CTiglExportIges. Could not translate shape "
+ shapeName + " to iges entity,", TIGL_ERROR);
}
PNamedShape theWire(new CNamedShape(Edges->Value(iwire),shapeName.c_str()));
theWire->SetShortName(shapeShortName.c_str());
WriteIGESShapeNames(FP, theWire, level);
WriteIgesWireName(FP, theWire);
}
}
}
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);
}
}
}
}
}
TopoDS_Face FaceTypedCylinder::buildFace(const FaceVectorType &faces) const
{
std::vector<EdgeVectorType> boundaries;
boundarySplit(faces, boundaries);
static TopoDS_Face dummy;
if (boundaries.size() < 1)
return dummy;
//take one face and remove all the wires.
TopoDS_Face workFace = faces.at(0);
ShapeBuild_ReShape reshaper;
TopExp_Explorer it;
for (it.Init(workFace, TopAbs_WIRE); it.More(); it.Next())
reshaper.Remove(it.Current());
workFace = TopoDS::Face(reshaper.Apply(workFace));
if (workFace.IsNull())
return TopoDS_Face();
ShapeFix_Face faceFixer(workFace);
//makes wires
std::vector<EdgeVectorType>::iterator boundaryIt;
for (boundaryIt = boundaries.begin(); boundaryIt != boundaries.end(); ++boundaryIt)
{
BRepLib_MakeWire wireMaker;
EdgeVectorType::iterator it;
for (it = (*boundaryIt).begin(); it != (*boundaryIt).end(); ++it)
wireMaker.Add(*it);
if (wireMaker.Error() != BRepLib_WireDone)
continue;
faceFixer.Add(wireMaker.Wire());
}
if (faceFixer.Perform() > ShapeExtend_DONE5)
return TopoDS_Face();
faceFixer.FixOrientation();
if (faceFixer.Perform() > ShapeExtend_DONE5)
return TopoDS_Face();
return faceFixer.Face();
}
App::DocumentObjectExecReturn *Thickness::execute(void)
{
App::DocumentObject* source = Faces.getValue();
if (!(source && source->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())))
return new App::DocumentObjectExecReturn("No source shape linked.");
const TopoShape& shape = static_cast<Part::Feature*>(source)->Shape.getShape();
if (shape.isNull())
return new App::DocumentObjectExecReturn("Source shape is empty.");
int countSolids = 0;
TopExp_Explorer xp;
xp.Init(shape._Shape,TopAbs_SOLID);
for (;xp.More(); xp.Next()) {
countSolids++;
}
if (countSolids != 1)
return new App::DocumentObjectExecReturn("Source shape is not a solid.");
TopTools_ListOfShape closingFaces;
const std::vector<std::string>& subStrings = Faces.getSubValues();
for (std::vector<std::string>::const_iterator it = subStrings.begin(); it != subStrings.end(); ++it) {
TopoDS_Face face = TopoDS::Face(shape.getSubShape(it->c_str()));
closingFaces.Append(face);
}
double thickness = Value.getValue();
double tol = Precision::Confusion();
bool inter = Intersection.getValue();
bool self = SelfIntersection.getValue();
short mode = (short)Mode.getValue();
short join = (short)Join.getValue();
if (fabs(thickness) > 2*tol)
this->Shape.setValue(shape.makeThickSolid(closingFaces, thickness, tol, inter, self, mode, join));
else
this->Shape.setValue(shape);
return App::DocumentObject::StdReturn;
}
