void SketcherGeneralWidget::loadSettings()
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Sketcher/General");
ui->checkBoxShowGrid->setChecked(hGrp->GetBool("ShowGrid", true));
ui->gridSize->setParamGrpPath(QByteArray("User parameter:BaseApp/History/SketchGridSize"));
ui->gridSize->setToLastUsedValue();
ui->checkBoxGridSnap->setChecked(hGrp->GetBool("GridSnap", ui->checkBoxGridSnap->isChecked()));
ui->checkBoxAutoconstraints->setChecked(hGrp->GetBool("AutoConstraints", ui->checkBoxAutoconstraints->isChecked()));
ParameterGrp::handle hGrpp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/Sketcher");
// 1->Normal Geometry, 2->Construction, 3->External
int topid = hGrpp->GetInt("TopRenderGeometryId",1);
int midid = hGrpp->GetInt("MidRenderGeometryId",2);
int lowid = hGrpp->GetInt("LowRenderGeometryId",3);
QListWidgetItem *newItem = new QListWidgetItem;
newItem->setData(Qt::UserRole, QVariant(topid));
newItem->setText( topid==1?tr("Normal Geometry"):topid==2?tr("Construction Geometry"):tr("External Geometry"));
ui->renderingOrder->insertItem(0,newItem);
newItem = new QListWidgetItem;
newItem->setData(Qt::UserRole, QVariant(midid));
newItem->setText(midid==1?tr("Normal Geometry"):midid==2?tr("Construction Geometry"):tr("External Geometry"));
ui->renderingOrder->insertItem(1,newItem);
newItem = new QListWidgetItem;
newItem->setData(Qt::UserRole, QVariant(lowid));
newItem->setText(lowid==1?tr("Normal Geometry"):lowid==2?tr("Construction Geometry"):tr("External Geometry"));
ui->renderingOrder->insertItem(2,newItem);
}
void DlgImportExportIges::loadSettings()
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part")->GetGroup("IGES");
int unit = hGrp->GetInt("Unit", 0);
ui->comboBoxUnits->setCurrentIndex(unit);
int value = Interface_Static::IVal("write.iges.brep.mode");
bool brep = hGrp->GetBool("BrepMode", value > 0);
if (brep)
ui->radioButtonBRepOn->setChecked(true);
else
ui->radioButtonBRepOff->setChecked(true);
// Import
ui->checkSkipBlank->setChecked(hGrp->GetBool("SkipBlankEntities", true));
// header info
ui->lineEditCompany->setText(QString::fromStdString(hGrp->GetASCII("Company",
Interface_Static::CVal("write.iges.header.company"))));
ui->lineEditAuthor->setText(QString::fromStdString(hGrp->GetASCII("Author",
Interface_Static::CVal("write.iges.header.author"))));
//ui->lineEditProduct->setText(QString::fromStdString(hGrp->GetASCII("Product")));
ui->lineEditProduct->setText(QString::fromLatin1(
Interface_Static::CVal("write.iges.header.product")));
}
void DrawViewPart::getRunControl()
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/TechDraw/RunControl");
m_sectionEdges = hGrp->GetBool("ShowSectionEdges", 1l);
m_handleFaces = hGrp->GetBool("HandleFaces", 1l);
}
void SketcherGeneralWidget::loadSettings()
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Sketcher/General");
ui->checkBoxShowGrid->setChecked(hGrp->GetBool("ShowGrid", true));
ui->gridSize->setParamGrpPath(QByteArray("User parameter:BaseApp/History/SketchGridSize"));
//ui->gridSize->setToLastUsedValue();
ui->checkBoxGridSnap->setChecked(hGrp->GetBool("GridSnap", ui->checkBoxGridSnap->isChecked()));
ui->checkBoxAutoconstraints->setChecked(hGrp->GetBool("AutoConstraints", ui->checkBoxAutoconstraints->isChecked()));
}
void DrawViewPart::getRunControl()
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/TechDraw/RunControl");
m_interAlgo = hGrp->GetInt("InterAlgo", 2l);
m_sectionEdges = hGrp->GetBool("ShowSectionEdges", 1l);
m_handleFaces = hGrp->GetBool("HandleFaces", 1l);
// Base::Console().Message("TRACE - DVP::getRunControl - interAlgo: %ld sectionFaces: %ld handleFaces: %ld\n",
// m_interAlgo,m_sectionEdges,m_handleFaces);
}
Py::Object ParameterGrpPy::getBool(const Py::Tuple& args)
{
char *pstr;
int Bool=0;
if (!PyArg_ParseTuple(args.ptr(), "s|i", &pstr,&Bool))
throw Py::Exception();
return Py::Boolean(_cParamGrp->GetBool(pstr,Bool!=0));
}
PyObject *ParameterGrpPy::PyGetBool(PyObject *args)
{
char *pstr;
int Bool=0;
if (!PyArg_ParseTuple(args, "s|i", &pstr,&Bool)) // convert args: Python->C
return NULL; // NULL triggers exception
PY_TRY {
return Py_BuildValue("i",_cParamGrp->GetBool(pstr,Bool!=0));
}PY_CATCH;
}
TopoDS_Shape Transformed::refineShapeIfActive(const TopoDS_Shape& oldShape) const
{
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/PartDesign");
if (hGrp->GetBool("RefineModel", false)) {
Part::BRepBuilderAPI_RefineModel mkRefine(oldShape);
TopoDS_Shape resShape = mkRefine.Shape();
return resShape;
}
return oldShape;
}
void ViewProviderMeshNode::attach(App::DocumentObject *pcFeat)
{
ViewProviderGeometryObject::attach(pcFeat);
// only one selection node for the mesh
const Mesh::Feature* meshFeature = dynamic_cast<Mesh::Feature*>(pcFeat);
MeshGui::SoFCMeshNode* mesh = new MeshGui::SoFCMeshNode();
mesh->setMesh(meshFeature->Mesh.getValuePtr());
pcHighlight->addChild(mesh);
// faces
SoGroup* pcFlatRoot = new SoGroup();
// read the correct shape color from the preferences
Base::Reference<ParameterGrp> hGrp = Gui::WindowParameter::getDefaultParameter()->GetGroup("Mod/Mesh");
bool twoSide = hGrp->GetBool("TwoSideRendering", true);
if ( twoSide )
{
// enable two-side rendering
SoShapeHints * flathints = new SoShapeHints;
flathints->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE;
flathints->shapeType = SoShapeHints::UNKNOWN_SHAPE_TYPE;
pcFlatRoot->addChild(flathints);
}
pcFlatRoot->addChild(pcShapeMaterial);
pcFlatRoot->addChild(pcHighlight);
addDisplayMaskMode(pcFlatRoot, "Flat");
// points
SoGroup* pcPointRoot = new SoGroup();
pcPointRoot->addChild(pcPointStyle);
pcPointRoot->addChild(pcFlatRoot);
addDisplayMaskMode(pcPointRoot, "Point");
// wires
SoLightModel* pcLightModel = new SoLightModel();
pcLightModel->model = SoLightModel::BASE_COLOR;
SoGroup* pcWireRoot = new SoGroup();
pcWireRoot->addChild(pcLineStyle);
pcWireRoot->addChild(pcLightModel);
pcWireRoot->addChild(pcShapeMaterial);
pcWireRoot->addChild(pcHighlight);
addDisplayMaskMode(pcWireRoot, "Wireframe");
// faces+wires
SoGroup* pcFlatWireRoot = new SoGroup();
pcFlatWireRoot->addChild(pcFlatRoot);
pcFlatWireRoot->addChild(pcWireRoot);
addDisplayMaskMode(pcFlatWireRoot, "FlatWireframe");
}
MultiFuse::MultiFuse(void)
{
ADD_PROPERTY(Shapes,(0));
Shapes.setSize(0);
ADD_PROPERTY_TYPE(History,(ShapeHistory()), "Boolean", (App::PropertyType)
(App::Prop_Output|App::Prop_Transient|App::Prop_Hidden), "Shape history");
History.setSize(0);
ADD_PROPERTY_TYPE(Refine,(0),"Boolean",(App::PropertyType)(App::Prop_None),"Refine shape (clean up redundant edges) after this boolean operation");
//init Refine property
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part/Boolean");
this->Refine.setValue(hGrp->GetBool("RefineModel", false));
}
static PyObject * importer(PyObject *self, PyObject *args)
{
char* Name;
char* DocName=0;
if (!PyArg_ParseTuple(args, "et|s","utf-8",&Name,&DocName))
return 0;
std::string Utf8Name = std::string(Name);
PyMem_Free(Name);
std::string name8bit = Part::encodeFilename(Utf8Name);
PY_TRY {
//Base::Console().Log("Insert in Part with %s",Name);
Base::FileInfo file(Utf8Name.c_str());
App::Document *pcDoc = 0;
if (DocName) {
pcDoc = App::GetApplication().getDocument(DocName);
}
if (!pcDoc) {
pcDoc = App::GetApplication().newDocument("Unnamed");
}
Handle(XCAFApp_Application) hApp = XCAFApp_Application::GetApplication();
Handle(TDocStd_Document) hDoc;
hApp->NewDocument(TCollection_ExtendedString("MDTV-CAF"), hDoc);
if (file.hasExtension("stp") || file.hasExtension("step")) {
try {
STEPCAFControl_Reader aReader;
aReader.SetColorMode(true);
aReader.SetNameMode(true);
aReader.SetLayerMode(true);
if (aReader.ReadFile((const char*)name8bit.c_str()) != IFSelect_RetDone) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "cannot read STEP file");
return 0;
}
Handle_Message_ProgressIndicator pi = new Part::ProgressIndicator(100);
aReader.Reader().WS()->MapReader()->SetProgress(pi);
pi->NewScope(100, "Reading STEP file...");
pi->Show();
aReader.Transfer(hDoc);
pi->EndScope();
}
catch (OSD_Exception) {
Handle_Standard_Failure e = Standard_Failure::Caught();
Base::Console().Error("%s\n", e->GetMessageString());
Base::Console().Message("Try to load STEP file without colors...\n");
Part::ImportStepParts(pcDoc,Utf8Name.c_str());
pcDoc->recompute();
}
}
else if (file.hasExtension("igs") || file.hasExtension("iges")) {
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part")->GetGroup("IGES");
try {
IGESControl_Controller::Init();
IGESCAFControl_Reader aReader;
// http://www.opencascade.org/org/forum/thread_20603/?forum=3
aReader.SetReadVisible(hGrp->GetBool("SkipBlankEntities", true)
? Standard_True : Standard_False);
aReader.SetColorMode(true);
aReader.SetNameMode(true);
aReader.SetLayerMode(true);
if (aReader.ReadFile((const char*)name8bit.c_str()) != IFSelect_RetDone) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "cannot read IGES file");
return 0;
}
Handle_Message_ProgressIndicator pi = new Part::ProgressIndicator(100);
aReader.WS()->MapReader()->SetProgress(pi);
pi->NewScope(100, "Reading IGES file...");
pi->Show();
aReader.Transfer(hDoc);
pi->EndScope();
}
catch (OSD_Exception) {
Handle_Standard_Failure e = Standard_Failure::Caught();
Base::Console().Error("%s\n", e->GetMessageString());
Base::Console().Message("Try to load IGES file without colors...\n");
Part::ImportIgesParts(pcDoc,Utf8Name.c_str());
pcDoc->recompute();
}
}
else {
PyErr_SetString(Base::BaseExceptionFreeCADError, "no supported file format");
return 0;
}
ImportOCAFExt ocaf(hDoc, pcDoc, file.fileNamePure());
ocaf.loadShapes();
pcDoc->recompute();
}
catch (Standard_Failure) {
App::DocumentObjectExecReturn *MultiFuse::execute(void)
{
std::vector<TopoDS_Shape> s;
std::vector<App::DocumentObject*> obj = Shapes.getValues();
std::vector<App::DocumentObject*>::iterator it;
for (it = obj.begin(); it != obj.end(); ++it) {
if ((*it)->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())) {
s.push_back(static_cast<Part::Feature*>(*it)->Shape.getValue());
}
}
bool argumentsAreInCompound = false;
TopoDS_Shape compoundOfArguments;
//if only one source shape, and it is a compound - fuse children of the compound
if (s.size() == 1){
compoundOfArguments = s[0];
if (compoundOfArguments.ShapeType() == TopAbs_COMPOUND){
s.clear();
TopoDS_Iterator it(compoundOfArguments);
for (; it.More(); it.Next()) {
const TopoDS_Shape& aChild = it.Value();
s.push_back(aChild);
}
argumentsAreInCompound = true;
}
}
if (s.size() >= 2) {
try {
std::vector<ShapeHistory> history;
#if OCC_VERSION_HEX <= 0x060800
TopoDS_Shape resShape = s.front();
if (resShape.IsNull())
throw Base::Exception("Input shape is null");
for (std::vector<TopoDS_Shape>::iterator it = s.begin()+1; it != s.end(); ++it) {
if (it->IsNull())
throw Base::Exception("Input shape is null");
// Let's call algorithm computing a fuse operation:
BRepAlgoAPI_Fuse mkFuse(resShape, *it);
// Let's check if the fusion has been successful
if (!mkFuse.IsDone())
throw Base::Exception("Fusion failed");
resShape = mkFuse.Shape();
ShapeHistory hist1 = buildHistory(mkFuse, TopAbs_FACE, resShape, mkFuse.Shape1());
ShapeHistory hist2 = buildHistory(mkFuse, TopAbs_FACE, resShape, mkFuse.Shape2());
if (history.empty()) {
history.push_back(hist1);
history.push_back(hist2);
}
else {
for (std::vector<ShapeHistory>::iterator jt = history.begin(); jt != history.end(); ++jt)
*jt = joinHistory(*jt, hist1);
history.push_back(hist2);
}
}
#else
BRepAlgoAPI_Fuse mkFuse;
TopTools_ListOfShape shapeArguments,shapeTools;
shapeArguments.Append(s.front());
for (std::vector<TopoDS_Shape>::iterator it = s.begin()+1; it != s.end(); ++it) {
if (it->IsNull())
throw Base::Exception("Input shape is null");
shapeTools.Append(*it);
}
mkFuse.SetArguments(shapeArguments);
mkFuse.SetTools(shapeTools);
mkFuse.Build();
if (!mkFuse.IsDone())
throw Base::Exception("MultiFusion failed");
TopoDS_Shape resShape = mkFuse.Shape();
for (std::vector<TopoDS_Shape>::iterator it = s.begin(); it != s.end(); ++it) {
history.push_back(buildHistory(mkFuse, TopAbs_FACE, resShape, *it));
}
#endif
if (resShape.IsNull())
throw Base::Exception("Resulting shape is null");
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part/Boolean");
if (hGrp->GetBool("CheckModel", false)) {
BRepCheck_Analyzer aChecker(resShape);
if (! aChecker.IsValid() ) {
return new App::DocumentObjectExecReturn("Resulting shape is invalid");
}
}
if (hGrp->GetBool("RefineModel", false)) {
try {
TopoDS_Shape oldShape = resShape;
BRepBuilderAPI_RefineModel mkRefine(oldShape);
resShape = mkRefine.Shape();
ShapeHistory hist = buildHistory(mkRefine, TopAbs_FACE, resShape, oldShape);
for (std::vector<ShapeHistory>::iterator jt = history.begin(); jt != history.end(); ++jt)
*jt = joinHistory(*jt, hist);
}
catch (Standard_Failure) {
// do nothing
}
}
this->Shape.setValue(resShape);
if (argumentsAreInCompound){
//combine histories of every child of source compound into one
ShapeHistory overallHist;
TopTools_IndexedMapOfShape facesOfCompound;
TopAbs_ShapeEnum type = TopAbs_FACE;
TopExp::MapShapes(compoundOfArguments, type, facesOfCompound);
for (std::size_t iChild = 0; iChild < history.size(); iChild++){ //loop over children of source compound
//for each face of a child, find the inex of the face in compound, and assign the corresponding right-hand-size of the history
TopTools_IndexedMapOfShape facesOfChild;
TopExp::MapShapes(s[iChild], type, facesOfChild);
for(std::pair<const int,ShapeHistory::List> &histitem: history[iChild].shapeMap){ //loop over elements of history - that is - over faces of the child of source compound
int iFaceInChild = histitem.first;
ShapeHistory::List &iFacesInResult = histitem.second;
TopoDS_Shape srcFace = facesOfChild(iFaceInChild + 1); //+1 to convert our 0-based to OCC 1-bsed conventions
int iFaceInCompound = facesOfCompound.FindIndex(srcFace)-1;
overallHist.shapeMap[iFaceInCompound] = iFacesInResult; //this may overwrite existing info if the same face is used in several children of compound. This shouldn't be a problem, because the histories should match anyway...
}
}
history.clear();
history.push_back(overallHist);
}
this->History.setValues(history);
}
catch (Standard_Failure& e) {
return new App::DocumentObjectExecReturn(e.GetMessageString());
}
}
else {
throw Base::Exception("Not enough shape objects linked");
}
return App::DocumentObject::StdReturn;
}
void DlgExtrusion::apply()
{
if (ui->treeWidget->selectedItems().isEmpty()) {
QMessageBox::critical(this, windowTitle(),
tr("Select a shape for extrusion, first."));
return;
}
Gui::WaitCursor wc;
App::Document* activeDoc = App::GetApplication().getDocument(this->document.c_str());
if (!activeDoc) {
QMessageBox::critical(this, windowTitle(),
tr("The document '%1' doesn't exist.").arg(QString::fromUtf8(this->label.c_str())));
return;
}
activeDoc->openTransaction("Extrude");
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part");
bool addBaseName = hGrp->GetBool("AddBaseObjectName", false);
QString shape, type, name, label;
QList<QTreeWidgetItem *> items = ui->treeWidget->selectedItems();
for (QList<QTreeWidgetItem *>::iterator it = items.begin(); it != items.end(); ++it) {
shape = (*it)->data(0, Qt::UserRole).toString();
type = QString::fromLatin1("Part::Extrusion");
if (addBaseName) {
QString baseName = QString::fromLatin1("Extrude_%1").arg(shape);
label = QString::fromLatin1("%1_Extrude").arg((*it)->text(0));
name = QString::fromLatin1(activeDoc->getUniqueObjectName((const char*)baseName.toLatin1()).c_str());
}
else {
name = QString::fromLatin1(activeDoc->getUniqueObjectName("Extrude").c_str());
label = name;
}
double len = ui->dirLen->value();
double dirX = ui->dirX->value();
double dirY = ui->dirY->value();
double dirZ = ui->dirZ->value();
double angle = ui->taperAngle->value().getValue();
bool makeSolid = ui->makeSolid->isChecked();
// inspect geometry
App::DocumentObject* obj = activeDoc->getObject((const char*)shape.toLatin1());
if (!obj || !obj->isDerivedFrom(Part::Feature::getClassTypeId())) continue;
Part::Feature* fea = static_cast<Part::Feature*>(obj);
const TopoDS_Shape& data = fea->Shape.getValue();
if (data.IsNull()) continue;
// check for planes
if (ui->checkNormal->isChecked() && data.ShapeType() == TopAbs_FACE) {
BRepAdaptor_Surface adapt(TopoDS::Face(data));
if (adapt.GetType() == GeomAbs_Plane) {
double u = 0.5*(adapt.FirstUParameter() + adapt.LastUParameter());
double v = 0.5*(adapt.FirstVParameter() + adapt.LastVParameter());
BRepLProp_SLProps prop(adapt,u,v,1,Precision::Confusion());
if (prop.IsNormalDefined()) {
gp_Pnt pnt; gp_Vec vec;
// handles the orientation state of the shape
BRepGProp_Face(TopoDS::Face(data)).Normal(u,v,pnt,vec);
dirX = vec.X();
dirY = vec.Y();
dirZ = vec.Z();
}
}
}
QString code = QString::fromLatin1(
"FreeCAD.getDocument(\"%1\").addObject(\"%2\",\"%3\")\n"
"FreeCAD.getDocument(\"%1\").%3.Base = FreeCAD.getDocument(\"%1\").%4\n"
"FreeCAD.getDocument(\"%1\").%3.Dir = (%5,%6,%7)\n"
"FreeCAD.getDocument(\"%1\").%3.Solid = (%8)\n"
"FreeCAD.getDocument(\"%1\").%3.TaperAngle = (%9)\n"
"FreeCADGui.getDocument(\"%1\").%4.Visibility = False\n"
"FreeCAD.getDocument(\"%1\").%3.Label = '%10'\n")
.arg(QString::fromLatin1(this->document.c_str()))
.arg(type).arg(name).arg(shape)
.arg(dirX*len)
.arg(dirY*len)
.arg(dirZ*len)
.arg(makeSolid ? QLatin1String("True") : QLatin1String("False"))
.arg(angle)
.arg(label);
Gui::Application::Instance->runPythonCode((const char*)code.toLatin1());
QByteArray to = name.toLatin1();
QByteArray from = shape.toLatin1();
Gui::Command::copyVisual(to, "ShapeColor", from);
Gui::Command::copyVisual(to, "LineColor", from);
Gui::Command::copyVisual(to, "PointColor", from);
}
activeDoc->commitTransaction();
try {
ui->statusLabel->clear();
activeDoc->recompute();
ui->statusLabel->setText(QString::fromLatin1
("<span style=\" color:#55aa00;\">%1</span>").arg(tr("Succeeded")));
}
catch (const std::exception& e) {
ui->statusLabel->setText(QString::fromLatin1
("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed")));
Base::Console().Error("%s\n", e.what());
}
catch (const Base::Exception& e) {
ui->statusLabel->setText(QString::fromLatin1
("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed")));
Base::Console().Error("%s\n", e.what());
}
catch (...) {
ui->statusLabel->setText(QString::fromLatin1
("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed")));
Base::Console().Error("General error in extrusion\n");
}
}
App::DocumentObjectExecReturn *MultiFuse::execute(void)
{
std::vector<TopoDS_Shape> s;
std::vector<App::DocumentObject*> obj = Shapes.getValues();
std::vector<App::DocumentObject*>::iterator it;
for (it = obj.begin(); it != obj.end(); ++it) {
if ((*it)->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())) {
s.push_back(static_cast<Part::Feature*>(*it)->Shape.getValue());
}
}
if (s.size() >= 2) {
try {
std::vector<ShapeHistory> history;
TopoDS_Shape resShape = s.front();
if (resShape.IsNull())
throw Base::Exception("Input shape is null");
for (std::vector<TopoDS_Shape>::iterator it = s.begin()+1; it != s.end(); ++it) {
if (it->IsNull())
throw Base::Exception("Input shape is null");
// Let's call algorithm computing a fuse operation:
BRepAlgoAPI_Fuse mkFuse(resShape, *it);
// Let's check if the fusion has been successful
if (!mkFuse.IsDone())
throw Base::Exception("Fusion failed");
resShape = mkFuse.Shape();
ShapeHistory hist1 = buildHistory(mkFuse, TopAbs_FACE, resShape, mkFuse.Shape1());
ShapeHistory hist2 = buildHistory(mkFuse, TopAbs_FACE, resShape, mkFuse.Shape2());
if (history.empty()) {
history.push_back(hist1);
history.push_back(hist2);
}
else {
for (std::vector<ShapeHistory>::iterator jt = history.begin(); jt != history.end(); ++jt)
*jt = joinHistory(*jt, hist1);
history.push_back(hist2);
}
}
if (resShape.IsNull())
throw Base::Exception("Resulting shape is null");
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part/Boolean");
if (hGrp->GetBool("CheckModel", false)) {
BRepCheck_Analyzer aChecker(resShape);
if (! aChecker.IsValid() ) {
return new App::DocumentObjectExecReturn("Resulting shape is invalid");
}
}
if (hGrp->GetBool("RefineModel", false)) {
TopoDS_Shape oldShape = resShape;
BRepBuilderAPI_RefineModel mkRefine(oldShape);
resShape = mkRefine.Shape();
ShapeHistory hist = buildHistory(mkRefine, TopAbs_FACE, resShape, oldShape);
for (std::vector<ShapeHistory>::iterator jt = history.begin(); jt != history.end(); ++jt)
*jt = joinHistory(*jt, hist);
}
this->Shape.setValue(resShape);
this->History.setValues(history);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
return new App::DocumentObjectExecReturn(e->GetMessageString());
}
}
else {
throw Base::Exception("Not enough shape objects linked");
}
return App::DocumentObject::StdReturn;
}
void PartExport initPart()
{
std::stringstream str;
str << OCC_VERSION_MAJOR << "." << OCC_VERSION_MINOR << "." << OCC_VERSION_MAINTENANCE;
#ifdef OCC_VERSION_DEVELOPMENT
str << "." OCC_VERSION_DEVELOPMENT;
#endif
App::Application::Config()["OCC_VERSION"] = str.str();
Base::Console().Log("Module: Part\n");
// This is highly experimental and we should keep an eye on it
// if we have mysterious crashes
// The argument must be 'Standard_False' to avoid FPE caused by
// Python's cmath module.
#if !defined(_DEBUG)
OSD::SetSignal(Standard_False);
#endif
PyObject* partModule = Py_InitModule3("Part", Part_methods, module_part_doc); /* mod name, table ptr */
Base::Console().Log("Loading Part module... done\n");
PyObject* OCCError = 0;
if (PyObject_IsSubclass(Base::BaseExceptionFreeCADError,
PyExc_RuntimeError)) {
OCCError = PyErr_NewException("Part.OCCError",
Base::BaseExceptionFreeCADError, NULL);
}
else {
Base::Console().Error("Can not inherit Part.OCCError form BaseFreeCADError.\n");
OCCError = PyErr_NewException("Part.OCCError",
PyExc_RuntimeError, NULL);
}
Py_INCREF(OCCError);
PyModule_AddObject(partModule, "OCCError", OCCError);
PartExceptionOCCError = OCCError; //set global variable ;(
PartExceptionOCCDomainError = PyErr_NewException("Part.OCCDomainError",
PartExceptionOCCError, NULL);
Py_INCREF(PartExceptionOCCDomainError);
PyModule_AddObject(partModule, "OCCDomainError",
PartExceptionOCCDomainError);
PartExceptionOCCRangeError = PyErr_NewException("Part.OCCRangeError",
PartExceptionOCCDomainError, NULL);
Py_INCREF(PartExceptionOCCRangeError);
PyModule_AddObject(partModule, "OCCRangeError", PartExceptionOCCRangeError);
PartExceptionOCCConstructionError = PyErr_NewException(
"Part.OCCConstructionError", PartExceptionOCCDomainError, NULL);
Py_INCREF(PartExceptionOCCConstructionError);
PyModule_AddObject(partModule, "OCCConstructionError",
PartExceptionOCCConstructionError);
PartExceptionOCCDimensionError = PyErr_NewException(
"Part.OCCDimensionError", PartExceptionOCCDomainError, NULL);
Py_INCREF(PartExceptionOCCConstructionError);
PyModule_AddObject(partModule, "OCCDimensionError",
PartExceptionOCCDimensionError);
//rename the types properly to pickle and unpickle them
Part::TopoShapePy ::Type.tp_name = "Part.Shape";
Part::TopoShapeVertexPy ::Type.tp_name = "Part.Vertex";
Part::TopoShapeWirePy ::Type.tp_name = "Part.Wire";
Part::TopoShapeEdgePy ::Type.tp_name = "Part.Edge";
Part::TopoShapeSolidPy ::Type.tp_name = "Part.Solid";
Part::TopoShapeFacePy ::Type.tp_name = "Part.Face";
Part::TopoShapeCompoundPy ::Type.tp_name = "Part.Compound";
Part::TopoShapeCompSolidPy::Type.tp_name = "Part.CompSolid";
Part::TopoShapeShellPy ::Type.tp_name = "Part.Shell";
// Add Types to module
Base::Interpreter().addType(&Part::TopoShapePy ::Type,partModule,"Shape");
Base::Interpreter().addType(&Part::TopoShapeVertexPy ::Type,partModule,"Vertex");
Base::Interpreter().addType(&Part::TopoShapeWirePy ::Type,partModule,"Wire");
Base::Interpreter().addType(&Part::TopoShapeEdgePy ::Type,partModule,"Edge");
Base::Interpreter().addType(&Part::TopoShapeSolidPy ::Type,partModule,"Solid");
Base::Interpreter().addType(&Part::TopoShapeFacePy ::Type,partModule,"Face");
Base::Interpreter().addType(&Part::TopoShapeCompoundPy ::Type,partModule,"Compound");
Base::Interpreter().addType(&Part::TopoShapeCompSolidPy ::Type,partModule,"CompSolid");
Base::Interpreter().addType(&Part::TopoShapeShellPy ::Type,partModule,"Shell");
Base::Interpreter().addType(&Part::LinePy ::Type,partModule,"Line");
Base::Interpreter().addType(&Part::PointPy ::Type,partModule,"Point");
Base::Interpreter().addType(&Part::CirclePy ::Type,partModule,"Circle");
Base::Interpreter().addType(&Part::EllipsePy ::Type,partModule,"Ellipse");
Base::Interpreter().addType(&Part::HyperbolaPy ::Type,partModule,"Hyperbola");
Base::Interpreter().addType(&Part::ParabolaPy ::Type,partModule,"Parabola");
Base::Interpreter().addType(&Part::ArcPy ::Type,partModule,"Arc");
Base::Interpreter().addType(&Part::ArcOfCirclePy ::Type,partModule,"ArcOfCircle");
Base::Interpreter().addType(&Part::ArcOfEllipsePy ::Type,partModule,"ArcOfEllipse");
Base::Interpreter().addType(&Part::ArcOfParabolaPy ::Type,partModule,"ArcOfParabola");
Base::Interpreter().addType(&Part::ArcOfHyperbolaPy ::Type,partModule,"ArcOfHyperbola");
Base::Interpreter().addType(&Part::BezierCurvePy ::Type,partModule,"BezierCurve");
Base::Interpreter().addType(&Part::BSplineCurvePy ::Type,partModule,"BSplineCurve");
Base::Interpreter().addType(&Part::OffsetCurvePy ::Type,partModule,"OffsetCurve");
Base::Interpreter().addType(&Part::PlanePy ::Type,partModule,"Plane");
Base::Interpreter().addType(&Part::CylinderPy ::Type,partModule,"Cylinder");
Base::Interpreter().addType(&Part::ConePy ::Type,partModule,"Cone");
Base::Interpreter().addType(&Part::SpherePy ::Type,partModule,"Sphere");
Base::Interpreter().addType(&Part::ToroidPy ::Type,partModule,"Toroid");
Base::Interpreter().addType(&Part::BezierSurfacePy ::Type,partModule,"BezierSurface");
Base::Interpreter().addType(&Part::BSplineSurfacePy ::Type,partModule,"BSplineSurface");
Base::Interpreter().addType(&Part::OffsetSurfacePy ::Type,partModule,"OffsetSurface");
Base::Interpreter().addType(&Part::SurfaceOfExtrusionPy ::Type,partModule,"SurfaceOfExtrusion");
Base::Interpreter().addType(&Part::SurfaceOfRevolutionPy::Type,partModule,"SurfaceOfRevolution");
Base::Interpreter().addType(&Part::RectangularTrimmedSurfacePy
::Type,partModule,"RectangularTrimmedSurface");
Base::Interpreter().addType(&Part::PartFeaturePy ::Type,partModule,"Feature");
PyObject* brepModule = Py_InitModule3("BRepOffsetAPI", 0, "BrepOffsetAPI");
Py_INCREF(brepModule);
PyModule_AddObject(partModule, "BRepOffsetAPI", brepModule);
Base::Interpreter().addType(&Part::BRepOffsetAPI_MakePipeShellPy::Type,brepModule,"MakePipeShell");
Part::TopoShape ::init();
Part::PropertyPartShape ::init();
Part::PropertyGeometryList ::init();
Part::PropertyShapeHistory ::init();
Part::PropertyFilletEdges ::init();
Part::Feature ::init();
Part::FeatureExt ::init();
Part::FeaturePython ::init();
Part::FeatureGeometrySet ::init();
Part::CustomFeature ::init();
Part::CustomFeaturePython ::init();
Part::Primitive ::init();
Part::Box ::init();
Part::Fractal ::init();
Part::Spline ::init();
Part::Boolean ::init();
Part::Common ::init();
Part::MultiCommon ::init();
Part::Cut ::init();
Part::Fuse ::init();
Part::MultiFuse ::init();
Part::Section ::init();
Part::FilletBase ::init();
Part::Fillet ::init();
Part::Chamfer ::init();
Part::Compound ::init();
Part::Extrusion ::init();
Part::Revolution ::init();
Part::Mirroring ::init();
Part::ImportStep ::init();
Part::ImportIges ::init();
Part::ImportBrep ::init();
Part::CurveNet ::init();
Part::Polygon ::init();
Part::Circle ::init();
Part::Ellipse ::init();
Part::Vertex ::init();
Part::Line ::init();
Part::Ellipsoid ::init();
Part::Plane ::init();
Part::Sphere ::init();
Part::Cylinder ::init();
Part::Prism ::init();
Part::RegularPolygon ::init();
Part::Cone ::init();
Part::Torus ::init();
Part::Helix ::init();
Part::Spiral ::init();
Part::Wedge ::init();
Part::Part2DObject ::init();
Part::Part2DObjectPython ::init();
Part::RuledSurface ::init();
Part::Loft ::init();
Part::Sweep ::init();
Part::Offset ::init();
Part::Thickness ::init();
// Geometry types
Part::Geometry ::init();
Part::GeomPoint ::init();
Part::GeomCurve ::init();
Part::GeomBezierCurve ::init();
Part::GeomBSplineCurve ::init();
Part::GeomCircle ::init();
Part::GeomArcOfCircle ::init();
Part::GeomArcOfEllipse ::init();
Part::GeomArcOfParabola ::init();
Part::GeomArcOfHyperbola ::init();
Part::GeomEllipse ::init();
Part::GeomHyperbola ::init();
Part::GeomParabola ::init();
Part::GeomLine ::init();
Part::GeomLineSegment ::init();
Part::GeomOffsetCurve ::init();
Part::GeomTrimmedCurve ::init();
Part::GeomSurface ::init();
Part::GeomBezierSurface ::init();
Part::GeomBSplineSurface ::init();
Part::GeomCylinder ::init();
Part::GeomCone ::init();
Part::GeomSphere ::init();
Part::GeomToroid ::init();
Part::GeomPlane ::init();
Part::GeomOffsetSurface ::init();
Part::GeomTrimmedSurface ::init();
Part::GeomSurfaceOfRevolution ::init();
Part::GeomSurfaceOfExtrusion ::init();
IGESControl_Controller::Init();
STEPControl_Controller::Init();
// set the user-defined settings
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part");
// General
Base::Reference<ParameterGrp> hGenGrp = hGrp->GetGroup("General");
// http://www.opencascade.org/org/forum/thread_20801/
// read.surfacecurve.mode:
// A preference for the computation of curves in an entity which has both 2D and 3D representation.
// Each TopoDS_Edge in TopoDS_Face must have a 3D and 2D curve that references the surface.
// If both 2D and 3D representation of the entity are present, the computation of these curves depends on
// the following values of parameter:
// 0: "Default" - no preference, both curves are taken
// 3: "3DUse_Preferred" - 3D curves are used to rebuild 2D ones
// Additional modes for IGES
// 2: "2DUse_Preferred" - the 2D is used to rebuild the 3D in case of their inconsistency
// -2: "2DUse_Forced" - the 2D is always used to rebuild the 3D (even if 2D is present in the file)
// -3: "3DUse_Forced" - the 3D is always used to rebuild the 2D (even if 2D is present in the file)
int readsurfacecurve = hGenGrp->GetInt("ReadSurfaceCurveMode", 0);
Interface_Static::SetIVal("read.surfacecurve.mode", readsurfacecurve);
// write.surfacecurve.mode (STEP-only):
// This parameter indicates whether parametric curves (curves in parametric space of surface) should be
// written into the STEP file. This parameter can be set to Off in order to minimize the size of the resulting
// STEP file.
// Off (0) : writes STEP files without pcurves. This mode decreases the size of the resulting file.
// On (1) : (default) writes pcurves to STEP file
int writesurfacecurve = hGenGrp->GetInt("WriteSurfaceCurveMode", 1);
Interface_Static::SetIVal("write.surfacecurve.mode", writesurfacecurve);
//IGES handling
Base::Reference<ParameterGrp> hIgesGrp = hGrp->GetGroup("IGES");
int value = Interface_Static::IVal("write.iges.brep.mode");
bool brep = hIgesGrp->GetBool("BrepMode", value > 0);
Interface_Static::SetIVal("write.iges.brep.mode",brep ? 1 : 0);
Interface_Static::SetCVal("write.iges.header.company", hIgesGrp->GetASCII("Company").c_str());
Interface_Static::SetCVal("write.iges.header.author", hIgesGrp->GetASCII("Author").c_str());
//Interface_Static::SetCVal("write.iges.header.product", hIgesGrp->GetASCII("Product").c_str());
int unitIges = hIgesGrp->GetInt("Unit", 0);
switch (unitIges) {
case 1:
Interface_Static::SetCVal("write.iges.unit","M");
break;
case 2:
Interface_Static::SetCVal("write.iges.unit","IN");
break;
default:
Interface_Static::SetCVal("write.iges.unit","MM");
break;
}
//STEP handling
Base::Reference<ParameterGrp> hStepGrp = hGrp->GetGroup("STEP");
int unitStep = hStepGrp->GetInt("Unit", 0);
switch (unitStep) {
case 1:
Interface_Static::SetCVal("write.step.unit","M");
break;
case 2:
Interface_Static::SetCVal("write.step.unit","IN");
break;
default:
Interface_Static::SetCVal("write.step.unit","MM");
break;
}
std::string ap = hStepGrp->GetASCII("Scheme", Interface_Static::CVal("write.step.schema"));
Interface_Static::SetCVal("write.step.schema", ap.c_str());
}
void DlgExtrusion::apply()
{
try{
if (!validate())
throw Base::AbortException();
if (filter) //if still selecting edge - stop. This is important for visibility automation.
this->on_btnSelectEdge_clicked();
Gui::WaitCursor wc;
App::Document* activeDoc = App::GetApplication().getDocument(this->document.c_str());
if (!activeDoc) {
QMessageBox::critical(this, windowTitle(),
tr("The document '%1' doesn't exist.").arg(QString::fromUtf8(this->label.c_str())));
return;
}
activeDoc->openTransaction("Extrude");
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part");
bool addBaseName = hGrp->GetBool("AddBaseObjectName", false);
std::vector<App::DocumentObject*> objects = this->getShapesToExtrude();
for (App::DocumentObject* sourceObj: objects) {
assert(sourceObj);
if (!sourceObj->isDerivedFrom(Part::Feature::getClassTypeId())){
std::stringstream errmsg;
errmsg << "Object " << sourceObj->getNameInDocument() << " is not Part object (has no OCC shape). Can't extrude it.\n";
Base::Console().Error(errmsg.str().c_str());
continue;
}
std::string name;
name = sourceObj->getDocument()->getUniqueObjectName("Extrude").c_str();
if (addBaseName) {
//FIXME: implement
//QString baseName = QString::fromLatin1("Extrude_%1").arg(sourceObjectName);
//label = QString::fromLatin1("%1_Extrude").arg((*it)->text(0));
}
Gui::Command::doCommand(Gui::Command::Doc, "f = FreeCAD.getDocument('%s').addObject('Part::Extrusion', '%s')", sourceObj->getDocument()->getName(), name.c_str());
this->writeParametersToFeature(*(sourceObj->getDocument()->getObject(name.c_str())), sourceObj);
std::string sourceObjectName = sourceObj->getNameInDocument();
Gui::Command::copyVisual(name.c_str(), "ShapeColor", sourceObjectName.c_str());
Gui::Command::copyVisual(name.c_str(), "LineColor", sourceObjectName.c_str());
Gui::Command::copyVisual(name.c_str(), "PointColor", sourceObjectName.c_str());
Gui::Command::doCommand(Gui::Command::Gui,"f.Base.ViewObject.hide()");
}
activeDoc->commitTransaction();
Gui::Command::updateActive();
}
catch (Base::AbortException&){
throw;
}
catch (Base::Exception &err){
QMessageBox::critical(this, windowTitle(),
tr("Creating Extrusion failed.\n\n%1").arg(QString::fromUtf8(err.what())));
return;
}
catch(...) {
QMessageBox::critical(this, windowTitle(),
tr("Creating Extrusion failed.\n\n%1").arg(QString::fromUtf8("Unknown error")));
return;
}
}
void AutoSaver::saveDocument(const std::string& name, AutoSaveProperty& saver)
{
Gui::WaitCursor wc;
App::Document* doc = App::GetApplication().getDocument(name.c_str());
if (doc) {
// Set the document's current transient directory
std::string dirName = doc->TransientDir.getValue();
dirName += "/fc_recovery_files";
saver.dirName = dirName;
// Write recovery meta file
QFile file(QString::fromLatin1("%1/fc_recovery_file.xml")
.arg(QString::fromUtf8(doc->TransientDir.getValue())));
if (file.open(QFile::WriteOnly)) {
QTextStream str(&file);
str.setCodec("UTF-8");
str << "<?xml version='1.0' encoding='utf-8'?>" << endl
<< "<AutoRecovery SchemaVersion=\"1\">" << endl;
str << " <Status>Created</Status>" << endl;
str << " <Label>" << QString::fromUtf8(doc->Label.getValue()) << "</Label>" << endl; // store the document's current label
str << " <FileName>" << QString::fromUtf8(doc->FileName.getValue()) << "</FileName>" << endl; // store the document's current filename
str << "</AutoRecovery>" << endl;
file.close();
}
// make sure to tmp. disable saving thumbnails because this causes trouble if the
// associated 3d view is not active
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetParameterGroupByPath
("User parameter:BaseApp/Preferences/Document");
bool save = hGrp->GetBool("SaveThumbnail",false);
hGrp->SetBool("SaveThumbnail",false);
getMainWindow()->showMessage(tr("Please wait until the AutoRecovery file has been saved..."), 5000);
//qApp->processEvents();
// open extra scope to close ZipWriter properly
Base::StopWatch watch;
watch.start();
{
if (!this->compressed) {
RecoveryWriter writer(saver);
if (hGrp->GetBool("SaveBinaryBrep", true))
writer.setMode("BinaryBrep");
writer.putNextEntry("Document.xml");
doc->Save(writer);
// Special handling for Gui document.
doc->signalSaveDocument(writer);
// write additional files
writer.writeFiles();
}
else {
std::string fn = doc->TransientDir.getValue();
fn += "/fc_recovery_file.fcstd";
Base::FileInfo tmp(fn);
Base::ofstream file(tmp, std::ios::out | std::ios::binary);
if (file.is_open())
{
Base::ZipWriter writer(file);
if (hGrp->GetBool("SaveBinaryBrep", true))
writer.setMode("BinaryBrep");
writer.setComment("AutoRecovery file");
writer.setLevel(1); // apparently the fastest compression
writer.putNextEntry("Document.xml");
doc->Save(writer);
// Special handling for Gui document.
doc->signalSaveDocument(writer);
// write additional files
writer.writeFiles();
}
}
}
std::string str = watch.toString(watch.elapsed());
Base::Console().Log("Save AutoRecovery file: %s\n", str.c_str());
hGrp->SetBool("SaveThumbnail",save);
}
}
Py::Object TopoShapeEdgePy::getCurve() const
{
const TopoDS_Edge& e = TopoDS::Edge(getTopoShapePtr()->getShape());
BRepAdaptor_Curve adapt(e);
switch(adapt.GetType())
{
case GeomAbs_Line:
{
static bool LineOld = true;
static bool init = false;
if (!init) {
init = true;
Base::Reference<ParameterGrp> hPartGrp = App::GetApplication().GetUserParameter()
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part");
Base::Reference<ParameterGrp> hGenPGrp = hPartGrp->GetGroup("General");
LineOld = hGenPGrp->GetBool("LineOld", false);
}
if (LineOld) {
GeomLineSegment* line = new GeomLineSegment();
Handle(Geom_TrimmedCurve) this_curv = Handle(Geom_TrimmedCurve)::DownCast
(line->handle());
Handle(Geom_Line) this_line = Handle(Geom_Line)::DownCast
(this_curv->BasisCurve());
this_line->SetLin(adapt.Line());
this_curv->SetTrim(adapt.FirstParameter(), adapt.LastParameter());
PyErr_SetString(PyExc_DeprecationWarning,
"For future usage 'Curve' will return 'Line' which is infinite "
"instead of the limited 'LineSegment'.\n"
"If you need a line segment then use this:\n"
"Part.LineSegment(edge.Curve,edge.FirstParameter,edge.LastParameter)\n"
"To suppress the warning set BaseApp/Preferences/Mod/Part/General/LineOld to false");
PyErr_Print();
return Py::Object(new LineSegmentPy(line),true); // LinePyOld
}
else {
GeomLine* line = new GeomLine();
Handle(Geom_Line) this_curv = Handle(Geom_Line)::DownCast
(line->handle());
this_curv->SetLin(adapt.Line());
return Py::Object(new LinePy(line),true);
}
}
case GeomAbs_Circle:
{
GeomCircle* circle = new GeomCircle();
Handle(Geom_Circle) this_curv = Handle(Geom_Circle)::DownCast
(circle->handle());
this_curv->SetCirc(adapt.Circle());
//Standard_Real dd = adapt.FirstParameter();
//Standard_Real ee = adapt.LastParameter();
return Py::Object(new CirclePy(circle),true);
}
case GeomAbs_Ellipse:
{
GeomEllipse* elips = new GeomEllipse();
Handle(Geom_Ellipse) this_curv = Handle(Geom_Ellipse)::DownCast
(elips->handle());
this_curv->SetElips(adapt.Ellipse());
return Py::Object(new EllipsePy(elips),true);
}
case GeomAbs_Hyperbola:
{
GeomHyperbola* hypr = new GeomHyperbola();
Handle(Geom_Hyperbola) this_curv = Handle(Geom_Hyperbola)::DownCast
(hypr->handle());
this_curv->SetHypr(adapt.Hyperbola());
return Py::Object(new HyperbolaPy(hypr),true);
}
case GeomAbs_Parabola:
{
GeomParabola* parab = new GeomParabola();
Handle(Geom_Parabola) this_curv = Handle(Geom_Parabola)::DownCast
(parab->handle());
this_curv->SetParab(adapt.Parabola());
return Py::Object(new ParabolaPy(parab),true);
}
case GeomAbs_BezierCurve:
{
GeomBezierCurve* curve = new GeomBezierCurve(adapt.Bezier());
return Py::Object(new BezierCurvePy(curve),true);
}
case GeomAbs_BSplineCurve:
{
GeomBSplineCurve* curve = new GeomBSplineCurve(adapt.BSpline());
return Py::Object(new BSplineCurvePy(curve),true);
}
#if OCC_VERSION_HEX >= 0x070000
case GeomAbs_OffsetCurve:
{
Standard_Real first, last;
Handle(Geom_Curve) c = BRep_Tool::Curve(e, first, last);
Handle(Geom_OffsetCurve) off = Handle(Geom_OffsetCurve)::DownCast(c);
if (!off.IsNull()) {
GeomOffsetCurve* curve = new GeomOffsetCurve(off);
return Py::Object(new OffsetCurvePy(curve),true);
}
else {
throw Py::RuntimeError("Failed to convert to offset curve");
}
}
#endif
case GeomAbs_OtherCurve:
break;
}
throw Py::TypeError("undefined curve type");
}