MeshObject* MeshObject::createMeshFromList(Py::List& list)
{
std::vector<MeshCore::MeshGeomFacet> facets;
MeshCore::MeshGeomFacet facet;
int i = 0;
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
Py::List item(*it);
for (int j = 0; j < 3; j++) {
Py::Float value(item[j]);
facet._aclPoints[i][j] = (float)value;
}
if (++i == 3) {
i = 0;
facet.CalcNormal();
facets.push_back(facet);
}
}
Base::EmptySequencer seq;
std::auto_ptr<MeshObject> mesh(new MeshObject);
//mesh->addFacets(facets);
mesh->getKernel() = facets;
return mesh.release();
}
PyObject* MeshPy::addFacets(PyObject *args)
{
PyObject *list;
if (PyArg_ParseTuple(args, "O!", &PyList_Type, &list)) {
Py::List list_f(list);
union PyType_Object pyVType = {&(Base::VectorPy::Type)};
Py::Type vVType(pyVType.o);
union PyType_Object pyFType = {&(Mesh::FacetPy::Type)};
Py::Type vFType(pyFType.o);
std::vector<MeshCore::MeshGeomFacet> facets;
MeshCore::MeshGeomFacet facet;
for (Py::List::iterator it = list_f.begin(); it != list_f.end(); ++it) {
if ((*it).isType(vFType)) {
Mesh::FacetPy* face = static_cast<Mesh::FacetPy*>((*it).ptr());
facets.push_back(*face->getFacetPtr());
}
else if ((*it).isSequence()) {
Py::Sequence seq(*it);
if (seq.size() == 3) {
if (PyFloat_Check(seq[0].ptr())) {
// every three triples build a triangle
facet._aclPoints[0] = Base::getVectorFromTuple<float>((*it).ptr());
++it;
facet._aclPoints[1] = Base::getVectorFromTuple<float>((*it).ptr());
++it;
facet._aclPoints[2] = Base::getVectorFromTuple<float>((*it).ptr());
}
else if (seq[0].isSequence()) {
// a sequence of sequence of flots
for (int i=0; i<3; i++) {
facet._aclPoints[i] = Base::getVectorFromTuple<float>(seq[i].ptr());
}
}
else if (PyObject_TypeCheck(seq[0].ptr(), &(Base::VectorPy::Type))) {
// a sequence of vectors
for (int i=0; i<3; i++) {
Base::Vector3d p = Py::Vector(seq[i]).toVector();
facet._aclPoints[i].Set((float)p.x,(float)p.y,(float)p.z);
}
}
else {
PyErr_SetString(PyExc_Exception, "expect a sequence of floats or Vector");
return NULL;
}
facet.CalcNormal();
facets.push_back(facet);
}
else {
// 9 consecutive floats expected
int index=0;
for (int i=0; i<3; i++) {
facet._aclPoints[i].x = (float)(double)Py::Float(seq[index++]);
facet._aclPoints[i].y = (float)(double)Py::Float(seq[index++]);
facet._aclPoints[i].z = (float)(double)Py::Float(seq[index++]);
}
facet.CalcNormal();
facets.push_back(facet);
}
} // sequence
}
getMeshObjectPtr()->addFacets(facets);
Py_Return;
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &PyTuple_Type, &list)) {
Py::Tuple tuple(list);
Py::List list_v(tuple.getItem(0));
std::vector<Base::Vector3f> vertices;
union PyType_Object pyVertType = {&(Base::VectorPy::Type)};
Py::Type vType(pyVertType.o);
for (Py::List::iterator it = list_v.begin(); it != list_v.end(); ++it) {
if ((*it).isType(vType)) {
Base::Vector3d v = static_cast<Base::VectorPy*>((*it).ptr())->value();
vertices.push_back(Base::Vector3f((float)v.x,(float)v.y,(float)v.z));
}
}
Py::List list_f(tuple.getItem(1));
MeshCore::MeshFacetArray faces;
for (Py::List::iterator it = list_f.begin(); it != list_f.end(); ++it) {
Py::Tuple f(*it);
MeshCore::MeshFacet face;
face._aulPoints[0] = (long)Py::Int(f.getItem(0));
face._aulPoints[1] = (long)Py::Int(f.getItem(1));
face._aulPoints[2] = (long)Py::Int(f.getItem(2));
faces.push_back(face);
}
getMeshObjectPtr()->addFacets(faces, vertices);
Py_Return;
}
PyErr_SetString(PyExc_Exception, "either expect\n"
"-- [Vector] (3 of them define a facet)\n"
"-- ([Vector],[(int,int,int)])");
return NULL;
}
