Py::Object exporter(const Py::Tuple& args)
{
PyObject* object;
char* Name;
if (!PyArg_ParseTuple(args.ptr(), "Oet",&object,"utf-8",&Name))
throw Py::Exception();
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
Py::Sequence list(object);
Base::Type meshId = Base::Type::fromName("Fem::FemMeshObject");
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
if (obj->getTypeId().isDerivedFrom(meshId)) {
static_cast<FemMeshObject*>(obj)->FemMesh.getValue().write(EncodedName.c_str());
break;
}
}
}
return Py::None();
}
Py::Object ParameterGrpPy::isEmpty(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), ""))
throw Py::Exception();
return Py::Boolean(_cParamGrp->IsEmpty());
}
Py::Object View3DInventorViewerPy::seekToPoint(const Py::Tuple& args)
{
PyObject* object;
if (!PyArg_ParseTuple(args.ptr(), "O", &object))
throw Py::Exception();
try {
const Py::Tuple tuple(object);
// If the 3d point is given
if (tuple.size() == 3) {
Py::Float x = tuple[0];
Py::Float y = tuple[1];
Py::Float z = tuple[2];
SbVec3f hitpoint((float)x,(float)y,(float)z);
_viewer->seekToPoint(hitpoint);
}
else {
Py::Int x(tuple[0]);
Py::Int y(tuple[1]);
SbVec2s hitpoint ((long)x,(long)y);
_viewer->seekToPoint(hitpoint);
}
return Py::None();
}
catch (const Py::Exception&) {
throw;
}
}
Py::Object ProgressIndicatorPy::stop(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), ""))
throw Py::Exception();
_seq.reset();
return Py::None();
}
Py::Object removeSvgTags(const Py::Tuple& args)
{
const char* svgcode;
if (!PyArg_ParseTuple(args.ptr(), "s",&svgcode))
throw Py::Exception();
std::string svg(svgcode);
std::string empty = "";
std::string endline = "--endOfLine--";
std::string linebreak = "\\n";
// removing linebreaks for regex to work
boost::regex e1 ("\\n");
svg = boost::regex_replace(svg, e1, endline);
// removing starting xml definition
boost::regex e2 ("<\\?xml.*?\\?>");
svg = boost::regex_replace(svg, e2, empty);
// removing starting svg tag
boost::regex e3 ("<svg.*?>");
svg = boost::regex_replace(svg, e3, empty);
// removing sodipodi tags -- DANGEROUS, some sodipodi tags are single, better leave it
//boost::regex e4 ("<sodipodi.*?>");
//svg = boost::regex_replace(svg, e4, empty);
// removing metadata tags
boost::regex e5 ("<metadata.*?</metadata>");
svg = boost::regex_replace(svg, e5, empty);
// removing closing svg tags
boost::regex e6 ("</svg>");
svg = boost::regex_replace(svg, e6, empty);
// restoring linebreaks
boost::regex e7 ("--endOfLine--");
svg = boost::regex_replace(svg, e7, linebreak);
Py::String result(svg);
return result;
}
Py::Object View3DInventorViewerPy::setFocalDistance(const Py::Tuple& args)
{
float distance;
if (!PyArg_ParseTuple(args.ptr(), "f", &distance))
throw Py::Exception();
try {
SoCamera* cam = _viewer->getSoRenderManager()->getCamera();
if (cam)
cam->focalDistance.setValue(distance);
}
catch (const Py::Exception&) {
throw; // re-throw
}
catch (const Base::Exception& e) {
throw Py::Exception(e.what());
}
catch (const std::exception& e) {
throw Py::Exception(e.what());
}
catch(...) {
throw Py::Exception("Unknown C++ exception");
}
return Py::None();
}
Py::Object projectEx(const Py::Tuple& args)
{
PyObject *pcObjShape;
PyObject *pcObjDir=0;
if (!PyArg_ParseTuple(args.ptr(), "O!|O!",
&(TopoShapePy::Type), &pcObjShape,
&(Base::VectorPy::Type), &pcObjDir))
throw Py::Exception();
TopoShapePy* pShape = static_cast<TopoShapePy*>(pcObjShape);
Base::Vector3d Vector(0,0,1);
if (pcObjDir)
Vector = *static_cast<Base::VectorPy*>(pcObjDir)->getVectorPtr();
ProjectionAlgos Alg(pShape->getTopoShapePtr()->getShape(),Vector);
Py::List list;
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.V)) , true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.V1)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.VN)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.VO)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.VI)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.H)) , true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.H1)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.HN)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.HO)), true));
list.append(Py::Object(new TopoShapePy(new TopoShape(Alg.HI)), true));
return list;
}
Py::Object projectToDXF(const Py::Tuple& args)
{
PyObject *pcObjShape;
PyObject *pcObjDir=0;
const char *type=0;
float scale=1.0f;
float tol=0.1f;
if (!PyArg_ParseTuple(args.ptr(), "O!|O!sff",
&(TopoShapePy::Type), &pcObjShape,
&(Base::VectorPy::Type), &pcObjDir, &type, &scale, &tol))
throw Py::Exception();
TopoShapePy* pShape = static_cast<TopoShapePy*>(pcObjShape);
Base::Vector3d Vector(0,0,1);
if (pcObjDir)
Vector = static_cast<Base::VectorPy*>(pcObjDir)->value();
ProjectionAlgos Alg(pShape->getTopoShapePtr()->getShape(),Vector);
bool hidden = false;
if (type && std::string(type) == "ShowHiddenLines")
hidden = true;
Py::String result(Alg.getDXF(hidden?ProjectionAlgos::WithHidden:ProjectionAlgos::Plain, scale, tol));
return result;
}
Py::Object wireFromSegment(const Py::Tuple& args)
{
PyObject *o, *m;
if (!PyArg_ParseTuple(args.ptr(), "O!O!", &(Mesh::MeshPy::Type), &m,&PyList_Type,&o))
throw Py::Exception();
Py::List list(o);
Mesh::MeshObject* mesh = static_cast<Mesh::MeshPy*>(m)->getMeshObjectPtr();
std::vector<unsigned long> segm;
segm.reserve(list.size());
for (unsigned int i=0; i<list.size(); i++) {
segm.push_back((int)Py::Int(list[i]));
}
std::list<std::vector<Base::Vector3f> > bounds;
MeshCore::MeshAlgorithm algo(mesh->getKernel());
algo.GetFacetBorders(segm, bounds);
Py::List wires;
std::list<std::vector<Base::Vector3f> >::iterator bt;
for (bt = bounds.begin(); bt != bounds.end(); ++bt) {
BRepBuilderAPI_MakePolygon mkPoly;
for (std::vector<Base::Vector3f>::reverse_iterator it = bt->rbegin(); it != bt->rend(); ++it) {
mkPoly.Add(gp_Pnt(it->x,it->y,it->z));
}
if (mkPoly.IsDone()) {
PyObject* wire = new Part::TopoShapeWirePy(new Part::TopoShape(mkPoly.Wire()));
wires.append(Py::Object(wire, true));
}
}
return wires;
}
Py::Object insert(const Py::Tuple& args)
{
char* Name;
const char* DocName = 0;
if (!PyArg_ParseTuple(args.ptr(), "et|s","utf-8",&Name,&DocName))
throw Py::Exception();
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
App::Document *pcDoc = 0;
if (DocName)
pcDoc = App::GetApplication().getDocument(DocName);
else
pcDoc = App::GetApplication().getActiveDocument();
if (!pcDoc) {
pcDoc = App::GetApplication().newDocument(DocName);
}
std::auto_ptr<FemMesh> mesh(new FemMesh);
mesh->read(EncodedName.c_str());
Base::FileInfo file(EncodedName.c_str());
FemMeshObject *pcFeature = static_cast<FemMeshObject *>
(pcDoc->addObject("Fem::FemMeshObject", file.fileNamePure().c_str()));
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->FemMesh.setValuePtr(mesh.get());
(void)mesh.release();
pcFeature->purgeTouched();
return Py::None();
}
Py::Object write(const Py::Tuple& args)
{
char* Name;
PyObject* pObj;
if (!PyArg_ParseTuple(args.ptr(), "Oet",&pObj,"utf-8",&Name))
throw Py::Exception();
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
Base::FileInfo file(EncodedName.c_str());
if (PyObject_TypeCheck(pObj, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(pObj)->getDocumentObjectPtr();
if (obj->getTypeId().isDerivedFrom(Base::Type::fromName("Path::Feature"))) {
const Toolpath& path = static_cast<Path::Feature*>(obj)->Path.getValue();
std::string gcode = path.toGCode();
std::ofstream ofile(EncodedName.c_str());
ofile << gcode;
ofile.close();
}
else {
throw Py::RuntimeError("The given file is not a path");
}
}
return Py::None();
}
Py::Object show(const Py::Tuple& args)
{
PyObject *pcObj;
if (!PyArg_ParseTuple(args.ptr(), "O!", &(PathPy::Type), &pcObj))
throw Py::Exception();
try {
App::Document *pcDoc = App::GetApplication().getActiveDocument();
if (!pcDoc)
pcDoc = App::GetApplication().newDocument();
PathPy* pPath = static_cast<PathPy*>(pcObj);
Path::Feature *pcFeature = (Path::Feature *)pcDoc->addObject("Path::Feature", "Path");
Path::Toolpath* pa = pPath->getToolpathPtr();
if (!pa) {
throw Py::Exception(PyExc_ReferenceError, "object doesn't reference a valid path");
}
// copy the data
pcFeature->Path.setValue(*pa);
}
catch (const Base::Exception& e) {
throw Py::RuntimeError(e.what());
}
return Py::None();
}
Py::Object openBrowserHTML(const Py::Tuple& args)
{
const char* HtmlCode;
const char* BaseUrl;
char* TabName = nullptr;
if (! PyArg_ParseTuple(args.ptr(), "ss|et", &HtmlCode, &BaseUrl, "utf-8", &TabName))
throw Py::Exception();
std::string EncodedName = "Browser";
if (TabName) {
EncodedName = std::string(TabName);
PyMem_Free(TabName);
}
WebGui::BrowserView* pcBrowserView = 0;
pcBrowserView = new WebGui::BrowserView(Gui::getMainWindow());
pcBrowserView->resize(400, 300);
pcBrowserView->setHtml(QString::fromUtf8(HtmlCode),QUrl(QString::fromLatin1(BaseUrl)));
pcBrowserView->setWindowTitle(QString::fromUtf8(EncodedName.c_str()));
Gui::getMainWindow()->addWindow(pcBrowserView);
if (!Gui::getMainWindow()->activeWindow())
Gui::getMainWindow()->setActiveWindow(pcBrowserView);
return Py::None();
}
Py::Object PythonDebugExcept::excepthook(const Py::Tuple& args)
{
PyObject *exc, *value, *tb;
if (!PyArg_UnpackTuple(args.ptr(), "excepthook", 3, 3, &exc, &value, &tb))
throw Py::Exception();
PyErr_NormalizeException(&exc, &value, &tb);
PyErr_Display(exc, value, tb);
/*
if (eEXCEPTMODE_IGNORE != g_eExceptionMode)
{
assert(tb);
if (tb && (tb != Py_None))
{
//get the pointer to the frame held by the bottom traceback object - this
//should be where the exception occurred.
tracebackobject* pTb = (tracebackobject*)tb;
while (pTb->tb_next != NULL)
{
pTb = pTb->tb_next;
}
PyFrameObject* frame = (PyFrameObject*)PyObject_GetAttr((PyObject*)pTb, PyString_FromString("tb_frame"));
EnterBreakState(frame, (PyObject*)pTb);
}
}*/
return Py::None();
}
Py::Object DocumentProtectorPy::recompute(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), ""))
throw Py::Exception();
Base::PyGILStateRelease unlock;
_dp->recompute();
return Py::None();
}
Py::Object View3DInventorViewerPy::getPickRadius(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), ""))
throw Py::Exception();
double d = _viewer->getPickRadius();
return Py::Float(d);
}
Py::Object ParameterGrpPy::hasGroup(const Py::Tuple& args)
{
char *pstr;
if (!PyArg_ParseTuple(args.ptr(), "s", &pstr))
throw Py::Exception();
return Py::Boolean(_cParamGrp->HasGroup(pstr));
}
Py::Object StdMeshers_Arithmetic1DPy::getLength(const Py::Tuple& args)
{
int start;
if (!PyArg_ParseTuple(args.ptr(), "i",&start))
throw Py::Exception();
return Py::Float(hypothesis<StdMeshers_Arithmetic1D>()->
GetLength(start ? true : false));
}
Py::Object ParameterGrpPy::notifyAll(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), ""))
throw Py::Exception();
_cParamGrp->NotifyAll();
return Py::None();
}
Py::Object ParameterGrpPy::getFloat(const Py::Tuple& args)
{
char *pstr;
double Float=0.0;
if (!PyArg_ParseTuple(args.ptr(), "s|d", &pstr,&Float))
throw Py::Exception();
return Py::Float(_cParamGrp->GetFloat(pstr,Float));
}
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));
}
Py::Object ParameterGrpPy::notify(const Py::Tuple& args)
{
char *pstr;
if (!PyArg_ParseTuple(args.ptr(), "s", &pstr))
throw Py::Exception();
_cParamGrp->Notify(pstr);
return Py::None();
}
Py::Object ParameterGrpPy::remString(const Py::Tuple& args)
{
char *pstr;
if (!PyArg_ParseTuple(args.ptr(), "s", &pstr))
throw Py::Exception();
_cParamGrp->RemoveASCII(pstr);
return Py::None();
}
Py::Object ParameterGrpPy::getString(const Py::Tuple& args)
{
char *pstr;
char * str="";
if (!PyArg_ParseTuple(args.ptr(), "s|s", &pstr,&str))
throw Py::Exception();
return Py::String(_cParamGrp->GetASCII(pstr,str));
}
Py::Object ParameterGrpPy::setBool(const Py::Tuple& args)
{
char *pstr;
int Bool;
if (!PyArg_ParseTuple(args.ptr(), "si", &pstr,&Bool))
throw Py::Exception();
_cParamGrp->SetBool(pstr,Bool!=0);
return Py::None();
}
Py::Object ParameterGrpPy::setInt(const Py::Tuple& args)
{
char *pstr;
int Int;
if (!PyArg_ParseTuple(args.ptr(), "si", &pstr,&Int))
throw Py::Exception();
_cParamGrp->SetInt(pstr,Int);
return Py::None();
}
Py::Object ProgressIndicatorPy::start(const Py::Tuple& args)
{
char* text;
int steps;
if (!PyArg_ParseTuple(args.ptr(), "si",&text,&steps))
throw Py::Exception();
if (!_seq.get())
_seq.reset(new SequencerLauncher(text,steps));
return Py::None();
}
Py::Object ParameterGrpPy::setUnsigned(const Py::Tuple& args)
{
char *pstr;
unsigned int UInt;
if (!PyArg_ParseTuple(args.ptr(), "sI", &pstr,&UInt))
throw Py::Exception();
_cParamGrp->SetUnsigned(pstr,UInt);
return Py::None();
}
Py::Object ParameterGrpPy::setFloat(const Py::Tuple& args)
{
char *pstr;
double Float;
if (!PyArg_ParseTuple(args.ptr(), "sd", &pstr,&Float))
throw Py::Exception();
_cParamGrp->SetFloat(pstr,Float);
return Py::None();
}
Py::Object ParameterGrpPy::setString(const Py::Tuple& args)
{
char *pstr;
char * str;
if (!PyArg_ParseTuple(args.ptr(), "ss", &pstr,&str))
throw Py::Exception();
_cParamGrp->SetASCII(pstr,str);
return Py::None();
}