Py::Object CyPy_Element::mapAsPyObject(const MapType& map, bool useNativePythonType)
{
Py::Dict dict;
for (auto& entry : map) {
if (useNativePythonType) {
dict.setItem(entry.first, CyPy_Element::asPyObject(entry.second, useNativePythonType));
} else {
dict.setItem(entry.first, CyPy_Element::wrap(entry.second));
}
}
return dict;
}
PyObject* Application::sSupportedLocales(PyObject * /*self*/, PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
TStringMap map = Translator::instance()->supportedLocales();
Py::Dict dict;
dict.setItem(Py::String("English"), Py::String("en"));
for (const auto& it : map) {
Py::String key(it.first);
Py::String val(it.second);
dict.setItem(key, val);
}
return Py::new_reference_to(dict);
}
Py::Dict TopoShapeFacePy::getPrincipalProperties(void) const
{
GProp_GProps props;
BRepGProp::SurfaceProperties(getTopoShapePtr()->getShape(), props);
GProp_PrincipalProps pprops = props.PrincipalProperties();
Py::Dict dict;
dict.setItem("SymmetryAxis", Py::Boolean(pprops.HasSymmetryAxis() ? true : false));
dict.setItem("SymmetryPoint", Py::Boolean(pprops.HasSymmetryPoint() ? true : false));
Standard_Real lx,ly,lz;
pprops.Moments(lx,ly,lz);
Py::Tuple tuple(3);
tuple.setItem(0, Py::Float(lx));
tuple.setItem(1, Py::Float(ly));
tuple.setItem(2, Py::Float(lz));
dict.setItem("Moments",tuple);
dict.setItem("FirstAxisOfInertia",Py::Vector(Base::convertTo
<Base::Vector3d>(pprops.FirstAxisOfInertia())));
dict.setItem("SecondAxisOfInertia",Py::Vector(Base::convertTo
<Base::Vector3d>(pprops.SecondAxisOfInertia())));
dict.setItem("ThirdAxisOfInertia",Py::Vector(Base::convertTo
<Base::Vector3d>(pprops.ThirdAxisOfInertia())));
Standard_Real Rxx,Ryy,Rzz;
pprops.RadiusOfGyration(Rxx,Ryy,Rzz);
Py::Tuple rog(3);
rog.setItem(0, Py::Float(Rxx));
rog.setItem(1, Py::Float(Ryy));
rog.setItem(2, Py::Float(Rzz));
dict.setItem("RadiusOfGyration",rog);
return dict;
}
PyObject* Application::sGetExportType(PyObject * /*self*/, PyObject *args,PyObject * /*kwd*/)
{
char* psKey=0;
if (!PyArg_ParseTuple(args, "|s", &psKey)) // convert args: Python->C
return NULL; // NULL triggers exception
if (psKey) {
Py::List list;
std::vector<std::string> modules = GetApplication().getExportModules(psKey);
for (std::vector<std::string>::iterator it = modules.begin(); it != modules.end(); ++it) {
list.append(Py::String(*it));
}
return Py::new_reference_to(list);
}
else {
Py::Dict dict;
std::vector<std::string> types = GetApplication().getExportTypes();
for (std::vector<std::string>::iterator it = types.begin(); it != types.end(); ++it) {
std::vector<std::string> modules = GetApplication().getExportModules(it->c_str());
if (modules.empty()) {
dict.setItem(it->c_str(), Py::None());
}
else if (modules.size() == 1) {
dict.setItem(it->c_str(), Py::String(modules.front()));
}
else {
Py::List list;
for (std::vector<std::string>::iterator jt = modules.begin(); jt != modules.end(); ++jt) {
list.append(Py::String(*jt));
}
dict.setItem(it->c_str(), list);
}
}
return Py::new_reference_to(dict);
}
}
PyObject* MeshPy::foraminate(PyObject *args)
{
PyObject* pnt_p;
PyObject* dir_p;
if (!PyArg_ParseTuple(args, "OO", &pnt_p, &dir_p))
return NULL;
try {
Py::Tuple pnt_t(pnt_p);
Py::Tuple dir_t(dir_p);
Base::Vector3f pnt((float)Py::Float(pnt_t.getItem(0)),
(float)Py::Float(pnt_t.getItem(1)),
(float)Py::Float(pnt_t.getItem(2)));
Base::Vector3f dir((float)Py::Float(dir_t.getItem(0)),
(float)Py::Float(dir_t.getItem(1)),
(float)Py::Float(dir_t.getItem(2)));
Base::Vector3f res;
MeshCore::MeshFacetIterator f_it(getMeshObjectPtr()->getKernel());
int index = 0;
Py::Dict dict;
for (f_it.Begin(); f_it.More(); f_it.Next(), index++) {
if (f_it->Foraminate(pnt, dir, res)) {
Py::Tuple tuple(3);
tuple.setItem(0, Py::Float(res.x));
tuple.setItem(1, Py::Float(res.y));
tuple.setItem(2, Py::Float(res.z));
dict.setItem(Py::Int(index), tuple);
}
}
return Py::new_reference_to(dict);
}
catch (const Py::Exception&) {
return 0;
}
}
PyObject* MeshPy::nearestFacetOnRay(PyObject *args)
{
PyObject* pnt_p;
PyObject* dir_p;
if (!PyArg_ParseTuple(args, "OO", &pnt_p, &dir_p))
return NULL;
try {
Py::Tuple pnt_t(pnt_p);
Py::Tuple dir_t(dir_p);
Py::Dict dict;
Base::Vector3f pnt((float)Py::Float(pnt_t.getItem(0)),
(float)Py::Float(pnt_t.getItem(1)),
(float)Py::Float(pnt_t.getItem(2)));
Base::Vector3f dir((float)Py::Float(dir_t.getItem(0)),
(float)Py::Float(dir_t.getItem(1)),
(float)Py::Float(dir_t.getItem(2)));
unsigned long index = 0;
Base::Vector3f res;
MeshCore::MeshAlgorithm alg(getMeshObjectPtr()->getKernel());
#if 0 // for testing only
MeshCore::MeshFacetGrid grid(getMeshObjectPtr()->getKernel(),10);
// With grids we might search in the opposite direction, too
if (alg.NearestFacetOnRay(pnt, dir, grid, res, index) ||
alg.NearestFacetOnRay(pnt, -dir, grid, res, index)) {
#else
if (alg.NearestFacetOnRay(pnt, dir, res, index)) {
#endif
Py::Tuple tuple(3);
tuple.setItem(0, Py::Float(res.x));
tuple.setItem(1, Py::Float(res.y));
tuple.setItem(2, Py::Float(res.z));
dict.setItem(Py::Int((int)index), tuple);
}
#if 0 // for testing only
char szBuf[200];
std::ofstream str("grid_test.iv");
Base::InventorBuilder builder(str);
MeshCore::MeshGridIterator g_it(grid);
for (g_it.Init(); g_it.More(); g_it.Next()) {
Base::BoundBox3f box = g_it.GetBoundBox();
unsigned long uX,uY,uZ;
g_it.GetGridPos(uX,uY,uZ);
builder.addBoundingBox(Base::Vector3f(box.MinX,box.MinY, box.MinZ),
Base::Vector3f(box.MaxX,box.MaxY, box.MaxZ));
sprintf(szBuf, "(%lu,%lu,%lu)", uX, uY, uZ);
builder.addText(box.CalcCenter(), szBuf);
}
builder.addSingleArrow(pnt-20.0f*dir, pnt+10.0f*dir);
builder.close();
str.close();
#endif
return Py::new_reference_to(dict);
}
catch (const Py::Exception&) {
return 0;
}
}