// Set the face traits void SetFaceTraits (PNamedShape loft) { // designated names of the faces std::vector<std::string> names(5); names[0]="Bottom"; names[1]="Top"; names[2]="TrailingEdge"; names[3]="Inside"; names[4]="Outside"; // map of faces TopTools_IndexedMapOfShape map; TopExp::MapShapes(loft->Shape(), TopAbs_FACE, map); // check if number of faces is correct (only valid for ruled surfaces lofts) if (map.Extent() != 5 && map.Extent() != 4) { LOG(ERROR) << "CCPACSWingSegment: Unable to determine face names in ruled surface loft"; return; } // remove trailing edge name if there is no trailing edge if (map.Extent() == 4) { names.erase(names.begin()+2); } // set face trait names for (int i = 0; i < map.Extent(); i++) { CFaceTraits traits = loft->GetFaceTraits(i); traits.SetName(names[i].c_str()); loft->SetFaceTraits(i, traits); } }
void DrawUtil::countEdges(const char* text, const TopoDS_Shape& s) { TopTools_IndexedMapOfShape mapOfEdges; TopExp::MapShapes(s, TopAbs_EDGE, mapOfEdges); int num = mapOfEdges.Extent(); Base::Console().Message("COUNT - %s has %d edges\n",text,num); }
//======================================================================= //function : CloseContour //purpose : //======================================================================= Standard_Boolean GEOMImpl_HealingDriver::CloseContour (GEOMImpl_IHealing* theHI, const TopoDS_Shape& theOriginalShape, TopoDS_Shape& theOutShape) const { Standard_Boolean isByVertex = theHI->GetIsCommonVertex(); Handle(TColStd_HArray1OfInteger) aWires = theHI->GetWires(); ShHealOper_CloseContour aHealer (theOriginalShape); Standard_Boolean aResult = Standard_False; if ( aWires.IsNull() ) { if ( theOriginalShape.ShapeType() == TopAbs_WIRE ) aResult = aHealer.Perform(TopoDS::Wire(theOriginalShape), isByVertex, !isByVertex); } else { TopTools_SequenceOfShape aShapesWires; TopTools_IndexedMapOfShape aShapes; TopExp::MapShapes(theOriginalShape, aShapes); for (int i = 1; i <= aWires->Length(); i++) { int indexOfWire = aWires->Value(i); TopoDS_Shape aWire = aShapes.FindKey(indexOfWire); aShapesWires.Append(aWire); } aResult = aHealer.Perform( aShapesWires, isByVertex, !isByVertex ); } if (aResult) theOutShape = aHealer.GetResultShape(); else raiseNotDoneExeption( aHealer.GetErrorStatus() ); return aResult; }
//======================================================================= //function : RemoveHoles //purpose : //======================================================================= Standard_Boolean GEOMImpl_HealingDriver::RemoveHoles (GEOMImpl_IHealing* theHI, const TopoDS_Shape& theOriginalShape, TopoDS_Shape& theOutShape) const { Handle(TColStd_HArray1OfInteger) aWires = theHI->GetWires(); ShHealOper_FillHoles aHealer (theOriginalShape); Standard_Boolean aResult = Standard_False; if (aWires.IsNull()) { // remove all faces aResult = aHealer.Fill(); } else { TopTools_SequenceOfShape aShapesWires; TopTools_IndexedMapOfShape aShapes; TopExp::MapShapes(theOriginalShape, aShapes); for (int i = 1; i <= aWires->Length(); i++) { int indexOfWire = aWires->Value(i); TopoDS_Shape aWire = aShapes.FindKey(indexOfWire); aShapesWires.Append(aWire); } aResult = aHealer.Fill(aShapesWires); } if (aResult) theOutShape = aHealer.GetResultShape(); else raiseNotDoneExeption( aHealer.GetErrorStatus() ); return aResult; }
void TestMkFillet(){ TopoDS_Shape Box = BRepPrimAPI_MakeBox(10., 10., 10.); BRepFilletAPI_MakeFillet mkFillet(Box); TopTools_IndexedMapOfShape edges; TopExp::MapShapes(Box, TopAbs_EDGE, edges); TopoDS_Edge edge = TopoDS::Edge(edges.FindKey(3)); mkFillet.Add(1., 1., edge); mkFillet.Build(); TopoDS_Shape result = mkFillet.Shape(); TopTools_IndexedMapOfShape faces; TopExp::MapShapes(Box, TopAbs_FACE, faces); TopoDS_Face face = TopoDS::Face(faces.FindKey(3)); TopTools_ListOfShape modified = mkFillet.Modified(face); TopTools_ListIteratorOfListOfShape modIt; for (int i=1; modIt.More(); modIt.Next(), i++){ TopoDS_Face curFace = TopoDS::Face(modIt.Value()); TopoNamingHelper::WriteShape(curFace, "00_02_ModifiedFace", i); } TopoNamingHelper::WriteShape(result, "00_00_FilletResult"); TopoNamingHelper::WriteShape(face, "00_01_BaseFace_3"); }
//======================================================================= //function : FacePassKey //purpose : //======================================================================= void GEOMAlgo_GlueDetector::FacePassKey(const TopoDS_Face& aF, GEOMAlgo_PassKeyShape& aPK) { Standard_Integer i, aNbE; TopoDS_Shape aER; TopTools_ListOfShape aLE; TopTools_IndexedMapOfShape aME; // TopExp::MapShapes(aF, TopAbs_EDGE, aME); // aNbE=aME.Extent(); for (i=1; i<=aNbE; ++i) { const TopoDS_Shape& aE=aME(i); // const TopoDS_Edge& aEE=*((TopoDS_Edge*)&aE); if (BRep_Tool::Degenerated(aEE)) { continue; } // if (myOrigins.IsBound(aE)) { aER=myOrigins.Find(aE); } else { aER=aE; } aLE.Append(aER); } aPK.SetShapes(aLE); }
//======================================================================= //function : AddPointOnEdge //purpose : //======================================================================= Standard_Boolean GEOMImpl_HealingDriver::AddPointOnEdge (GEOMImpl_IHealing* theHI, const TopoDS_Shape& theOriginalShape, TopoDS_Shape& theOutShape) const { Standard_Boolean isByParameter = theHI->GetIsByParameter(); Standard_Integer anIndex = theHI->GetIndex(); Standard_Real aValue = theHI->GetDevideEdgeValue(); ShHealOper_EdgeDivide aHealer (theOriginalShape); Standard_Boolean aResult = Standard_False; if (anIndex == -1) { // apply algorythm for the whole shape which is EDGE if (theOriginalShape.ShapeType() == TopAbs_EDGE) aResult = aHealer.Perform(TopoDS::Edge(theOriginalShape), aValue, isByParameter); } else { TopTools_IndexedMapOfShape aShapes; TopExp::MapShapes(theOriginalShape, aShapes); TopoDS_Shape aEdgeShape = aShapes.FindKey(anIndex); if (aEdgeShape.ShapeType() == TopAbs_EDGE) aResult = aHealer.Perform(TopoDS::Edge(aEdgeShape), aValue, isByParameter); } if (aResult) theOutShape = aHealer.GetResultShape(); else raiseNotDoneExeption( aHealer.GetErrorStatus() ); return aResult; }
int StdMeshers_Hexa_3D::GetFaceIndex(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, const vector < SMESH_subMesh * >&meshFaces, const TopoDS_Vertex & V0, const TopoDS_Vertex & V1, const TopoDS_Vertex & V2, const TopoDS_Vertex & V3) { //MESSAGE("StdMeshers_Hexa_3D::GetFaceIndex"); int faceIndex = -1; for (int i = 1; i < 6; i++) { const TopoDS_Shape & aFace = meshFaces[i]->GetSubShape(); //const TopoDS_Face& F = TopoDS::Face(aFace); TopTools_IndexedMapOfShape M; TopExp::MapShapes(aFace, TopAbs_VERTEX, M); bool verticesInShape = false; if (M.Contains(V0)) if (M.Contains(V1)) if (M.Contains(V2)) if (M.Contains(V3)) verticesInShape = true; if (verticesInShape) { faceIndex = i; break; } } //IPAL21120 ASSERT(faceIndex > 0); //SCRUTE(faceIndex); return faceIndex; }
void ResultEntry::buildEntryName() { ResultEntry *parentEntry = this; while(parentEntry->parent != 0) { ResultEntry *temp = parentEntry->parent; if (temp->parent == 0) break; parentEntry = parentEntry->parent; } QString stringOut; QTextStream stream(&stringOut); TopTools_IndexedMapOfShape shapeMap; int index(-1); switch (this->shape.ShapeType()) { case TopAbs_COMPOUND: TopExp::MapShapes(parentEntry->shape, TopAbs_COMPOUND, shapeMap); stream << "Compound"; break; case TopAbs_COMPSOLID: TopExp::MapShapes(parentEntry->shape, TopAbs_COMPSOLID, shapeMap); stream << "CompSolid"; break; case TopAbs_SOLID: TopExp::MapShapes(parentEntry->shape, TopAbs_SOLID, shapeMap); stream << "Solid"; break; case TopAbs_SHELL: TopExp::MapShapes(parentEntry->shape, TopAbs_SHELL, shapeMap); stream << "Shell"; break; case TopAbs_WIRE: TopExp::MapShapes(parentEntry->shape, TopAbs_WIRE, shapeMap); stream << "Wire"; break; case TopAbs_FACE: TopExp::MapShapes(parentEntry->shape, TopAbs_FACE, shapeMap); stream << "Face"; break; case TopAbs_EDGE: TopExp::MapShapes(parentEntry->shape, TopAbs_EDGE, shapeMap); stream << "Edge"; break; case TopAbs_VERTEX: TopExp::MapShapes(parentEntry->shape, TopAbs_VERTEX, shapeMap); stream << "Vertex"; break; default: stream << "Unexpected shape type"; break; } index = shapeMap.FindIndex(this->shape); stream << index; this->name = stringOut; }
void DlgFilletEdges::on_shapeObject_activated(int index) { d->object = 0; QStandardItemModel *model = qobject_cast<QStandardItemModel*>(ui->treeView->model()); model->removeRows(0, model->rowCount()); QByteArray name = ui->shapeObject->itemData(index).toByteArray(); App::Document* doc = App::GetApplication().getActiveDocument(); if (!doc) return; App::DocumentObject* part = doc->getObject((const char*)name); if (part && part->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())) { d->object = part; TopoDS_Shape myShape = static_cast<Part::Feature*>(part)->Shape.getValue(); // build up map edge->face TopTools_IndexedDataMapOfShapeListOfShape edge2Face; TopExp::MapShapesAndAncestors(myShape, TopAbs_EDGE, TopAbs_FACE, edge2Face); TopTools_IndexedMapOfShape mapOfShape; TopExp::MapShapes(myShape, TopAbs_EDGE, mapOfShape); // populate the model d->edge_ids.clear(); for (int i=1; i<= edge2Face.Extent(); ++i) { // set the index value as user data to use it in accept() const TopTools_ListOfShape& los = edge2Face.FindFromIndex(i); if (los.Extent() == 2) { // set the index value as user data to use it in accept() const TopoDS_Shape& edge = edge2Face.FindKey(i); // Now check also the continuity to only allow C0-continious // faces const TopoDS_Shape& face1 = los.First(); const TopoDS_Shape& face2 = los.Last(); GeomAbs_Shape cont = BRep_Tool::Continuity(TopoDS::Edge(edge), TopoDS::Face(face1), TopoDS::Face(face2)); if (cont == GeomAbs_C0) { int id = mapOfShape.FindIndex(edge); d->edge_ids.push_back(id); } } } model->insertRows(0, d->edge_ids.size()); int index = 0; for (std::vector<int>::iterator it = d->edge_ids.begin(); it != d->edge_ids.end(); ++it) { model->setData(model->index(index, 0), QVariant(tr("Edge%1").arg(*it))); model->setData(model->index(index, 0), QVariant(*it), Qt::UserRole); model->setData(model->index(index, 1), QVariant(QLocale::system().toString(1.0,'f',2))); model->setData(model->index(index, 2), QVariant(QLocale::system().toString(1.0,'f',2))); std::stringstream element; element << "Edge" << *it; if (Gui::Selection().isSelected(part, element.str().c_str())) model->setData(model->index(index, 0), Qt::Checked, Qt::CheckStateRole); else model->setData(model->index(index, 0), Qt::Unchecked, Qt::CheckStateRole); index++; } } }
//======================================================================= //function : BuildResult //purpose : //======================================================================= void GEOMAlgo_Gluer2::BuildResult() { Standard_Boolean bHasImage; TopoDS_Shape aCnew, aCXnew; TopoDS_Iterator aItC; BRep_Builder aBB; // myErrorStatus=0; myWarningStatus=0; // aItC.Initialize(myArgument); for (; aItC.More(); aItC.Next()) { const TopoDS_Shape& aCx=aItC.Value(); bHasImage=HasImage(aCx); if (bHasImage) { break; } } // if (!bHasImage) { myShape=myArgument; return; } // GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew); // aItC.Initialize(myArgument); for (; aItC.More(); aItC.Next()) { const TopoDS_Shape& aCX=aItC.Value(); if (myOrigins.IsBound(aCX)) { aCXnew=myOrigins.Find(aCX); aCXnew.Orientation(aCX.Orientation()); aBB.Add(aCnew, aCXnew); } else { aBB.Add(aCnew, aCX); } } // if (!myKeepNonSolids) { Standard_Integer i, aNb; TopoDS_Shape aCnew1; TopTools_IndexedMapOfShape aM; // GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew1); // TopExp::MapShapes(aCnew, TopAbs_SOLID, aM); aNb=aM.Extent(); for (i=1; i<=aNb; ++i) { const TopoDS_Shape& aS=aM(i); aBB.Add(aCnew1, aS); } aCnew=aCnew1; } // myShape=aCnew; }
//======================================================================= //function : FillContainers //purpose : //======================================================================= void GEOMAlgo_Gluer2::FillContainers(const TopAbs_ShapeEnum aType) { Standard_Boolean bHasImage, bToReverse; Standard_Integer i, aNbW; TopoDS_Shape aWnew, aEnew; TopoDS_Iterator aItS; BRep_Builder aBB; TopTools_IndexedMapOfShape aMW; TopTools_MapOfShape aMFence; // myErrorStatus=0; myWarningStatus=0; // TopExp::MapShapes(myArgument, aType, aMW); // aNbW=aMW.Extent(); for (i=1; i<=aNbW; ++i) { const TopoDS_Shape& aW=aMW(i); // if (!aMFence.Add(aW)) { continue; } // bHasImage=HasImage(aW); if (!bHasImage) { continue; } // GEOMAlgo_Tools3D::MakeContainer(aType, aWnew); aWnew.Orientation(aW.Orientation()); // aItS.Initialize(aW); for (; aItS.More(); aItS.Next()) { const TopoDS_Shape& aE=aItS.Value(); if (myOrigins.IsBound(aE)) { aEnew=myOrigins.Find(aE); // bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aEnew, aE, myContext); if (bToReverse) { aEnew.Reverse(); } // aBB.Add(aWnew, aEnew); } else { aBB.Add(aWnew, aE); } } // //myImages / myOrigins TopTools_ListOfShape aLSD; // aLSD.Append(aW); myImages.Bind(aWnew, aLSD); myOrigins.Bind(aW, aWnew); // }//for (i=1; i<=aNbE; ++i) { }
//======================================================================= //function : Execute //purpose : //======================================================================= Standard_Integer GEOM_SubShapeDriver::Execute(TFunction_Logbook& log) const { if (Label().IsNull()) return 0; Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label()); GEOM_ISubShape aCI (aFunction); TDF_Label aLabel = aCI.GetMainShape()->GetOwnerEntry(); if (aLabel.IsRoot()) return 0; Handle(GEOM_Object) anObj = GEOM_Object::GetObject(aLabel); if (anObj.IsNull()) return 0; TopoDS_Shape aMainShape = anObj->GetValue(); if (aMainShape.IsNull()) return 0; Handle(TColStd_HArray1OfInteger) anIndices = aCI.GetIndices(); if (anIndices.IsNull() || anIndices->Length() <= 0) return 0; BRep_Builder B; TopoDS_Compound aCompound; TopoDS_Shape aShape; if (anIndices->Length() == 1 && anIndices->Value(1) == -1) { //The empty sub-shape B.MakeCompound(aCompound); aShape = aCompound; } else { TopTools_IndexedMapOfShape aMapOfShapes; TopExp::MapShapes(aMainShape, aMapOfShapes); if (anIndices->Length() > 1) { B.MakeCompound(aCompound); for (int i = anIndices->Lower(); i <= anIndices->Upper(); i++) { if (aMapOfShapes.Extent() < anIndices->Value(i)) Standard_NullObject::Raise("GEOM_SubShapeDriver::Execute: Index is out of range"); TopoDS_Shape aSubShape = aMapOfShapes.FindKey(anIndices->Value(i)); if (aSubShape.IsNull()) continue; B.Add(aCompound,aSubShape); } aShape = aCompound; } else { int i = anIndices->Lower(); if (aMapOfShapes.Extent() < anIndices->Value(i)) Standard_NullObject::Raise("GEOM_SubShapeDriver::Execute: Index is out of range"); aShape = aMapOfShapes.FindKey(anIndices->Value(i)); } } if (aShape.IsNull()) return 0; aFunction->SetValue(aShape); log.SetTouched(Label()); return 1; }
void LowLightAll() { for (int i = 1; i <= fmap.Extent(); i++) fvispar[i-1].Lowlight(); for (int i = 1; i <= emap.Extent(); i++) evispar[i-1].Lowlight(); for (int i = 1; i <= vmap.Extent(); i++) vvispar[i-1].Lowlight(); }
//======================================================================= //function : FillBRepShapes //purpose : //======================================================================= void GEOMAlgo_Gluer2::FillBRepShapes(const TopAbs_ShapeEnum theType) { Standard_Boolean bHasImage, bIsToWork; Standard_Integer i, aNbE; TopoDS_Iterator aItS; TopoDS_Shape aEnew; TopTools_IndexedMapOfShape aME; TopTools_MapOfShape aMFence; TopTools_ListIteratorOfListOfShape aItLS; // myErrorStatus=0; myWarningStatus=0; // TopExp::MapShapes(myArgument, theType, aME); // aNbE=aME.Extent(); for (i=1; i<=aNbE; ++i) { const TopoDS_Shape& aE=aME(i); // if (!aMFence.Add(aE)) { continue; } // bIsToWork=myOriginsToWork.IsBound(aE); bHasImage=HasImage(aE); if (!bHasImage && !bIsToWork) { continue; } // MakeBRepShapes(aE, aEnew); // //myImages / myOrigins if (bIsToWork) { const TopoDS_Shape& aSkey=myOriginsToWork.Find(aE); const TopTools_ListOfShape& aLSD=myImagesToWork.Find(aSkey); // myImages.Bind(aEnew, aLSD); // aItLS.Initialize(aLSD); for (; aItLS.More(); aItLS.Next()) { const TopoDS_Shape& aEx=aItLS.Value(); myOrigins.Bind(aEx, aEnew); // aMFence.Add(aEx); } } else { TopTools_ListOfShape aLSD; // aLSD.Append(aE); myImages.Bind(aEnew, aLSD); myOrigins.Bind(aE, aEnew); } }//for (i=1; i<=aNbF; ++i) { }
void ViewProviderShapeBinder::highlightReferences(const bool on, bool /*auxillery*/) { Part::Feature* obj; std::vector<std::string> subs; if(getObject()->isDerivedFrom(PartDesign::ShapeBinder::getClassTypeId())) PartDesign::ShapeBinder::getFilteredReferences(&static_cast<PartDesign::ShapeBinder*>(getObject())->Support, obj, subs); else return; PartGui::ViewProviderPart* svp = dynamic_cast<PartGui::ViewProviderPart*>( Gui::Application::Instance->getViewProvider(obj)); if (svp == NULL) return; if (on) { if (!subs.empty() && originalLineColors.empty()) { TopTools_IndexedMapOfShape eMap; TopExp::MapShapes(obj->Shape.getValue(), TopAbs_EDGE, eMap); originalLineColors = svp->LineColorArray.getValues(); std::vector<App::Color> lcolors = originalLineColors; lcolors.resize(eMap.Extent(), svp->LineColor.getValue()); TopExp::MapShapes(obj->Shape.getValue(), TopAbs_FACE, eMap); originalFaceColors = svp->DiffuseColor.getValues(); std::vector<App::Color> fcolors = originalFaceColors; fcolors.resize(eMap.Extent(), svp->ShapeColor.getValue()); for (std::string e : subs) { // Note: stoi may throw, but it strictly shouldn't happen if(e.substr(4) == "Edge") { int idx = std::stoi(e.substr(4)) - 1; assert ( idx>=0 ); if ( idx < (ssize_t) lcolors.size() ) lcolors[idx] = App::Color(1.0,0.0,1.0); // magenta } else if(e.substr(4) == "Face") { int idx = std::stoi(e.substr(4)) - 1; assert ( idx>=0 ); if ( idx < (ssize_t) fcolors.size() ) fcolors[idx] = App::Color(1.0,0.0,1.0); // magenta } } svp->LineColorArray.setValues(lcolors); svp->DiffuseColor.setValues(fcolors); } } else { if (!subs.empty() && !originalLineColors.empty()) { svp->LineColorArray.setValues(originalLineColors); originalLineColors.clear(); svp->DiffuseColor.setValues(originalFaceColors); originalFaceColors.clear(); } } }
void addFacesToSelection(Gui::View3DInventorViewer* /*viewer*/, const Gui::ViewVolumeProjection& proj, const Base::Polygon2d& polygon, const TopoDS_Shape& shape) { try { TopTools_IndexedMapOfShape M; TopExp_Explorer xp_face(shape,TopAbs_FACE); while (xp_face.More()) { M.Add(xp_face.Current()); xp_face.Next(); } App::Document* appdoc = doc->getDocument(); for (Standard_Integer k = 1; k <= M.Extent(); k++) { const TopoDS_Shape& face = M(k); TopExp_Explorer xp_vertex(face,TopAbs_VERTEX); while (xp_vertex.More()) { gp_Pnt p = BRep_Tool::Pnt(TopoDS::Vertex(xp_vertex.Current())); Base::Vector3d pt2d; pt2d = proj(Base::Vector3d(p.X(), p.Y(), p.Z())); if (polygon.Contains(Base::Vector2d(pt2d.x, pt2d.y))) { #if 0 // TODO if (isVisibleFace(k-1, SbVec2f(pt2d.x, pt2d.y), viewer)) #endif { std::stringstream str; str << "Face" << k; Gui::Selection().addSelection(appdoc->getName(), obj->getNameInDocument(), str.str().c_str()); break; } } xp_vertex.Next(); } //GProp_GProps props; //BRepGProp::SurfaceProperties(face, props); //gp_Pnt c = props.CentreOfMass(); //Base::Vector3d pt2d; //pt2d = proj(Base::Vector3d(c.X(), c.Y(), c.Z())); //if (polygon.Contains(Base::Vector2d(pt2d.x, pt2d.y))) { // if (isVisibleFace(k-1, SbVec2f(pt2d.x, pt2d.y), viewer)) { // std::stringstream str; // str << "Face" << k; // Gui::Selection().addSelection(appdoc->getName(), obj->getNameInDocument(), str.str().c_str()); // } //} } } catch (...) { } }
int OCCSurface::get_loops( DLIList<OCCLoop*>& result_list ) { TopTools_IndexedMapOfShape M; TopExp::MapShapes(*myTopoDSFace, TopAbs_WIRE, M); int ii; for (ii=1; ii<=M.Extent(); ii++) { TopologyBridge *loop = OCCQueryEngine::instance()->occ_to_cgm(M(ii)); result_list.append_unique(dynamic_cast<OCCLoop*>(loop)); } return result_list.size(); }
void OCCSurface::get_children_virt( DLIList<TopologyBridge*>& children ) { TopTools_IndexedMapOfShape M; TopExp::MapShapes(*myTopoDSFace, TopAbs_WIRE, M); int ii; for (ii=1; ii<=M.Extent(); ii++) { TopologyBridge *loop = OCCQueryEngine::instance()->occ_to_cgm(M(ii)); if(loop) children.append_unique(loop); } }
int OCCFace::numFaces() { TopTools_IndexedMapOfShape anIndices; const TopoDS_Shape& shp = this->getShape(); if (shp.ShapeType() == TopAbs_FACE) { return 1; } else { // Shell TopExp::MapShapes(shp, TopAbs_FACE, anIndices); return anIndices.Extent(); } }
void ViewProviderMultiCommon::updateData(const App::Property* prop) { PartGui::ViewProviderPart::updateData(prop); if (prop->getTypeId() == Part::PropertyShapeHistory::getClassTypeId()) { const std::vector<Part::ShapeHistory>& hist = static_cast<const Part::PropertyShapeHistory*> (prop)->getValues(); Part::MultiCommon* objBool = static_cast<Part::MultiCommon*>(getObject()); std::vector<App::DocumentObject*> sources = objBool->Shapes.getValues(); if (hist.size() != sources.size()) return; const TopoDS_Shape& boolShape = objBool->Shape.getValue(); TopTools_IndexedMapOfShape boolMap; TopExp::MapShapes(boolShape, TopAbs_FACE, boolMap); std::vector<App::Color> colBool; colBool.resize(boolMap.Extent(), this->ShapeColor.getValue()); bool setColor=false; int index=0; for (std::vector<App::DocumentObject*>::iterator it = sources.begin(); it != sources.end(); ++it, ++index) { Part::Feature* objBase = dynamic_cast<Part::Feature*>(*it); if (!objBase) continue; const TopoDS_Shape& baseShape = objBase->Shape.getValue(); TopTools_IndexedMapOfShape baseMap; TopExp::MapShapes(baseShape, TopAbs_FACE, baseMap); Gui::ViewProvider* vpBase = Gui::Application::Instance->getViewProvider(objBase); std::vector<App::Color> colBase = static_cast<PartGui::ViewProviderPart*>(vpBase)->DiffuseColor.getValues(); if (static_cast<int>(colBase.size()) == baseMap.Extent()) { applyColor(hist[index], colBase, colBool); setColor = true; } else if (!colBase.empty() && colBase[0] != this->ShapeColor.getValue()) { colBase.resize(baseMap.Extent(), colBase[0]); applyColor(hist[index], colBase, colBool); setColor = true; } } if (setColor) this->DiffuseColor.setValues(colBool); } else if (prop->getTypeId() == App::PropertyLinkList::getClassTypeId()) { std::vector<App::DocumentObject*> pShapes = static_cast<const App::PropertyLinkList*>(prop)->getValues(); for (std::vector<App::DocumentObject*>::iterator it = pShapes.begin(); it != pShapes.end(); ++it) { if (*it) Gui::Application::Instance->hideViewProvider(*it); } } }
TopoDS_Edge GetEdge(const TopoDS_Shape &shape, int iEdge) { TopTools_IndexedMapOfShape edgeMap; TopExp::MapShapes(shape, TopAbs_EDGE, edgeMap); if (iEdge < 0 || iEdge >= edgeMap.Extent()) { return TopoDS_Edge(); } else { return TopoDS::Edge(edgeMap(iEdge+1)); } }
PyObject* TopoShapeFacePy::validate(PyObject *args) { if (!PyArg_ParseTuple(args, "")) return 0; try { const TopoDS_Face& face = TopoDS::Face(getTopoShapePtr()->getShape()); BRepCheck_Analyzer aChecker(face); if (!aChecker.IsValid()) { TopoDS_Wire outerwire = ShapeAnalysis::OuterWire(face); TopTools_IndexedMapOfShape myMap; myMap.Add(outerwire); TopExp_Explorer xp(face,TopAbs_WIRE); ShapeFix_Wire fix; fix.SetFace(face); fix.Load(outerwire); fix.Perform(); BRepBuilderAPI_MakeFace mkFace(fix.WireAPIMake()); while (xp.More()) { if (!myMap.Contains(xp.Current())) { fix.Load(TopoDS::Wire(xp.Current())); fix.Perform(); mkFace.Add(fix.WireAPIMake()); } xp.Next(); } aChecker.Init(mkFace.Face()); if (!aChecker.IsValid()) { ShapeFix_Shape fix(mkFace.Face()); fix.SetPrecision(Precision::Confusion()); fix.SetMaxTolerance(Precision::Confusion()); fix.SetMaxTolerance(Precision::Confusion()); fix.Perform(); fix.FixWireTool()->Perform(); fix.FixFaceTool()->Perform(); getTopoShapePtr()->setShape(fix.Shape()); } else { getTopoShapePtr()->setShape(mkFace.Face()); } } Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
void OCCBody::get_all_curves(DLIList<OCCCurve*> &curves) { TopoDS_Shape *shape; get_TopoDS_Shape(shape); TopTools_IndexedMapOfShape M; TopExp::MapShapes(*shape, TopAbs_EDGE, M); int ii; for (ii=1; ii<=M.Extent(); ii++) { TopologyBridge *curve = OCCQueryEngine::instance()->occ_to_cgm(M(ii)); OCCCurve* occ_curve = CAST_TO(curve, OCCCurve); if (occ_curve) curves.append_unique(occ_curve); } }
App::DocumentObjectExecReturn *Fillet::execute(void) { App::DocumentObject* link = Base.getValue(); if (!link) return new App::DocumentObjectExecReturn("No object linked"); if (!link->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())) return new App::DocumentObjectExecReturn("Linked object is not a Part object"); Part::Feature *base = static_cast<Part::Feature*>(Base.getValue()); try { #if defined(__GNUC__) && defined (FC_OS_LINUX) Base::SignalException se; #endif BRepFilletAPI_MakeFillet mkFillet(base->Shape.getValue()); TopTools_IndexedMapOfShape mapOfShape; TopExp::MapShapes(base->Shape.getValue(), TopAbs_EDGE, mapOfShape); std::vector<FilletElement> values = Edges.getValues(); for (std::vector<FilletElement>::iterator it = values.begin(); it != values.end(); ++it) { int id = it->edgeid; double radius1 = it->radius1; double radius2 = it->radius2; const TopoDS_Edge& edge = TopoDS::Edge(mapOfShape.FindKey(id)); mkFillet.Add(radius1, radius2, edge); } TopoDS_Shape shape = mkFillet.Shape(); if (shape.IsNull()) return new App::DocumentObjectExecReturn("Resulting shape is null"); ShapeHistory history = buildHistory(mkFillet, TopAbs_FACE, shape, base->Shape.getValue()); this->Shape.setValue(shape); // make sure the 'PropertyShapeHistory' is not safed in undo/redo (#0001889) PropertyShapeHistory prop; prop.setValue(history); prop.setContainer(this); prop.touch(); return App::DocumentObject::StdReturn; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); return new App::DocumentObjectExecReturn(e->GetMessageString()); } catch (...) { return new App::DocumentObjectExecReturn("A fatal error occurred when making fillets"); } }
TopoDS_Vertex StdMeshers_Hexa_3D::OppositeVertex(const TopoDS_Vertex& aVertex, const TopTools_IndexedMapOfShape& aQuads0Vertices, FaceQuadStruct* aQuads[6]) { int i, j; for ( i = 1; i < 6; ++i ) { TopoDS_Vertex VV[] = { aQuads[i]->side[0]->FirstVertex(), aQuads[i]->side[0]->LastVertex() , aQuads[i]->side[2]->LastVertex() , aQuads[i]->side[2]->FirstVertex() }; for ( j = 0; j < 4; ++j ) if ( aVertex.IsSame( VV[ j ])) break; if ( j < 4 ) { int jPrev = j ? j - 1 : 3; int jNext = (j + 1) % 4; if ( aQuads0Vertices.Contains( VV[ jPrev ] )) return VV[ jNext ]; else return VV[ jPrev ]; } } return TopoDS_Vertex(); }
void FaceMakerExtrusion::Build() { this->NotDone(); this->myGenerated.Clear(); this->myShapesToReturn.clear(); this->myShape = TopoDS_Shape(); TopoDS_Shape inputShape; if (mySourceShapes.empty()) throw Base::Exception("No input shapes!"); if (mySourceShapes.size() == 1){ inputShape = mySourceShapes[0]; } else { TopoDS_Builder builder; TopoDS_Compound cmp; builder.MakeCompound(cmp); for (const TopoDS_Shape& sh: mySourceShapes){ builder.Add(cmp, sh); } inputShape = cmp; } std::vector<TopoDS_Wire> wires; TopTools_IndexedMapOfShape mapOfWires; TopExp::MapShapes(inputShape, TopAbs_WIRE, mapOfWires); // if there are no wires then check also for edges if (mapOfWires.IsEmpty()) { TopTools_IndexedMapOfShape mapOfEdges; TopExp::MapShapes(inputShape, TopAbs_EDGE, mapOfEdges); for (int i=1; i<=mapOfEdges.Extent(); i++) { BRepBuilderAPI_MakeWire mkWire(TopoDS::Edge(mapOfEdges.FindKey(i))); wires.push_back(mkWire.Wire()); } } else { wires.reserve(mapOfWires.Extent()); for (int i=1; i<=mapOfWires.Extent(); i++) { wires.push_back(TopoDS::Wire(mapOfWires.FindKey(i))); } } if (!wires.empty()) { //try { TopoDS_Shape res = FaceMakerCheese::makeFace(wires); if (!res.IsNull()) this->myShape = res; //} //catch (...) { //} } this->Done(); }
// Philippose - 17/01/2009 // Sets the currently selected face void SetSelectedFace(int facenr) { face_sel_status = 0; if((facenr >= 1) && (facenr <= fmap.Extent())) { face_sel_status[facenr-1] = 1; } }
//======================================================================= //function : IsGrowthWire //purpose : //======================================================================= Standard_Boolean IsGrowthWire(const TopoDS_Shape& theWire, const TopTools_IndexedMapOfShape& theMHE) { Standard_Boolean bRet; TopoDS_Iterator aIt; // bRet=Standard_False; if (theMHE.Extent()) { aIt.Initialize(theWire); for(; aIt.More(); aIt.Next()) { const TopoDS_Shape& aE=aIt.Value(); if (theMHE.Contains(aE)) { return !bRet; } } } return bRet; }
// Extract the face map from the OCC geometry // The face map basically gives an index to each face in the geometry, // which can be used to access a specific face DLL_HEADER Ng_Result Ng_OCC_GetFMap(Ng_OCC_Geometry * geom, Ng_OCC_TopTools_IndexedMapOfShape * FMap) { OCCGeometry* occgeom = (OCCGeometry*)geom; TopTools_IndexedMapOfShape *occfmap = (TopTools_IndexedMapOfShape *)FMap; // Copy the face map from the geometry to the given variable occfmap->Assign(occgeom->fmap); if(occfmap->Extent()) { return NG_OK; } else { return NG_ERROR; } }