From 310af7d73f96d4b58665ad149ac6ee0ac52928d2 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Thu, 23 Feb 2012 17:14:53 +0000 Subject: bmesh py api bmesh.utils.face_join(faces) added a utility function for converting a list of python BMesh elements into a C array. use for this face_join as well as BMesh.faces.new() --- source/blender/python/bmesh/bmesh_py_types.c | 177 ++++++++++++++++++--------- source/blender/python/bmesh/bmesh_py_types.h | 5 + source/blender/python/bmesh/bmesh_py_utils.c | 37 ++++++ 3 files changed, 160 insertions(+), 59 deletions(-) (limited to 'source/blender/python') diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c index 03dea9aff5f..83bda8c1343 100644 --- a/source/blender/python/bmesh/bmesh_py_types.c +++ b/source/blender/python/bmesh/bmesh_py_types.c @@ -913,68 +913,23 @@ static PyObject *bpy_bmface_seq_new(BPy_BMElemSeq *self, PyObject *args) } else { BMesh *bm = self->bm; - PyObject *vert_seq_fast; Py_ssize_t vert_seq_len; Py_ssize_t i, i_prev; - void *alloc; - BMVert **vert_array; - BMEdge **edge_array; + BMVert **vert_array = NULL; + BMEdge **edge_array = NULL; - BPy_BMVert *item; PyObject *ret = NULL; - int ok; - BMFace *f; + BMFace *f_new; if (py_face_example) { BPY_BM_CHECK_OBJ(py_face_example); } - if (!(vert_seq_fast=PySequence_Fast(vert_seq, "faces.new(...)"))) { - return NULL; - } - - vert_seq_len = PySequence_Fast_GET_SIZE(vert_seq_fast); - - alloc = PyMem_MALLOC(vert_seq_len * sizeof(BMVert **) + vert_seq_len * sizeof(BMEdge **)); - - vert_array = (BMVert **) alloc; - edge_array = (BMEdge **) &(((BMVert **)alloc)[vert_seq_len]); - - /* --- */ - for (i = 0; i < vert_seq_len; i++) { - item = (BPy_BMVert *)PySequence_Fast_GET_ITEM(vert_seq_fast, i); - - if (!BPy_BMVert_Check(item)) { - PyErr_Format(PyExc_TypeError, - "faces.new(verts): expected BMVert sequence, not '%.200s'", - Py_TYPE(item)->tp_name); - } - else if (item->bm != bm) { - PyErr_Format(PyExc_TypeError, - "faces.new(verts): %d vertex is from another mesh", i); - } - - vert_array[i] = item->v; - - BM_elem_flag_enable(item->v, BM_ELEM_TAG); - } - - /* check for double verts! */ - ok = TRUE; - for (i = 0; i < vert_seq_len; i++) { - if (UNLIKELY(BM_elem_flag_test(vert_array[i], BM_ELEM_TAG) == FALSE)) { - ok = FALSE; - } - BM_elem_flag_disable(item->v, BM_ELEM_TAG); - } - - if (ok == FALSE) { - PyErr_SetString(PyExc_ValueError, - "faces.new(verts): found the same vertex used multiple times"); - goto cleanup; - } + vert_array = bpy_bm_generic_py_seq_as_array(&bm, vert_seq, 3, PY_SSIZE_T_MAX, + &vert_seq_len, &BPy_BMVert_Type, + TRUE, TRUE, "faces.new(...)"); /* check if the face exists */ if (BM_face_exists(bm, vert_array, vert_seq_len, NULL)) { @@ -983,34 +938,34 @@ static PyObject *bpy_bmface_seq_new(BPy_BMElemSeq *self, PyObject *args) goto cleanup; } - /* Go ahead and make the face! * --------------------------- */ + edge_array = (BMEdge **)PyMem_MALLOC(vert_seq_len * sizeof(BMEdge **)); + /* ensure edges */ - ok = TRUE; for (i = 0, i_prev = vert_seq_len - 1; i < vert_seq_len; (i_prev=i++)) { edge_array[i] = BM_edge_create(bm, vert_array[i], vert_array[i_prev], NULL, TRUE); } - f = BM_face_create(bm, vert_array, edge_array, vert_seq_len, FALSE); + f_new = BM_face_create(bm, vert_array, edge_array, vert_seq_len, FALSE); - if (f == NULL) { + if (f_new == NULL) { PyErr_SetString(PyExc_ValueError, "faces.new(verts): couldn't create the new face, internal error"); goto cleanup; } if (py_face_example) { - BM_elem_attrs_copy(py_face_example->bm, bm, py_face_example->f, f); + BM_elem_attrs_copy(py_face_example->bm, bm, py_face_example->f, f_new); } - ret = BPy_BMFace_CreatePyObject(bm, f); + ret = BPy_BMFace_CreatePyObject(bm, f_new); /* pass through */ cleanup: - Py_DECREF(vert_seq_fast); - PyMem_FREE(alloc); + if (vert_array) PyMem_FREE(vert_array); + if (edge_array) PyMem_FREE(edge_array); return ret; } } @@ -1805,3 +1760,107 @@ void bpy_bm_generic_invalidate(BPy_BMGeneric *self) { self->bm = NULL; } + +/* generic python seq as BMVert/Edge/Face array, + * return value must be freed with PyMem_FREE(...); + * + * The 'bm_r' value is assigned when empty, and used when set. + */ +void *bpy_bm_generic_py_seq_as_array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_ssize_t max, Py_ssize_t *r_size, + PyTypeObject *type, + const char do_unique_check, const char do_bm_check, + const char *error_prefix) +{ + BMesh *bm = (r_bm && *r_bm) ? *r_bm : NULL; + PyObject *seq_fast; + *r_size = 0; + + if (!(seq_fast=PySequence_Fast(seq, error_prefix))) { + return NULL; + } + else { + Py_ssize_t seq_len; + Py_ssize_t i; + + BPy_BMElem *item; + BMHeader **alloc; + + seq_len = PySequence_Fast_GET_SIZE(seq_fast); + + if (seq_len < min || seq_len > max) { + PyErr_Format(PyExc_TypeError, + "%s: sequence incorrect size, expected [%d - %d], given %d", + error_prefix, min, max, seq_len); + return NULL; + } + + + /* from now on, use goto */ + alloc = PyMem_MALLOC(seq_len * sizeof(BPy_BMElem **)); + + for (i = 0; i < seq_len; i++) { + item = (BPy_BMElem *)PySequence_Fast_GET_ITEM(seq_fast, i); + + if (Py_TYPE(item) != type) { + PyErr_Format(PyExc_TypeError, + "%s: expected '%.200', not '%.200s'", + error_prefix, type->tp_name, Py_TYPE(item)->tp_name); + goto err_cleanup; + } + else if (item->bm == NULL) { + PyErr_Format(PyExc_TypeError, + "%s: %d %s has been removed", + error_prefix, i, type->tp_name); + goto err_cleanup; + } + /* trick so we can ensure all items have the same mesh, + * and allows us to pass the 'bm' as NULL. */ + else if (do_bm_check && (bm && bm != item->bm)) { + PyErr_Format(PyExc_TypeError, + "%s: %d %s is from another mesh", + error_prefix, i, type->tp_name); + goto err_cleanup; + } + + if (bm == NULL) { + bm = item->bm; + } + + alloc[i] = item->ele; + + if (do_unique_check) { + BM_elem_flag_enable(item->ele, BM_ELEM_TAG); + } + } + + if (do_unique_check) { + /* check for double verts! */ + int ok = TRUE; + for (i = 0; i < seq_len; i++) { + if (UNLIKELY(BM_elem_flag_test(alloc[i], BM_ELEM_TAG) == FALSE)) { + ok = FALSE; + } + + /* ensure we dont leave this enabled */ + BM_elem_flag_disable(alloc[i], BM_ELEM_TAG); + } + + if (ok == FALSE) { + PyErr_Format(PyExc_ValueError, + "%s: found the same %s used multiple times", + error_prefix, type->tp_name); + goto err_cleanup; + } + } + + Py_DECREF(seq_fast); + *r_size = seq_len; + if (r_bm) *r_bm = bm; + return alloc; + +err_cleanup: + Py_DECREF(seq_fast); + PyMem_FREE(alloc); + return NULL; + } +} diff --git a/source/blender/python/bmesh/bmesh_py_types.h b/source/blender/python/bmesh/bmesh_py_types.h index 70cbeba5804..e4bc6beb7cc 100644 --- a/source/blender/python/bmesh/bmesh_py_types.h +++ b/source/blender/python/bmesh/bmesh_py_types.h @@ -132,6 +132,11 @@ PyObject *BPy_BMElem_CreatePyObject(BMesh *bm, BMHeader *ele); /* just checks ty int bpy_bm_generic_valid_check(BPy_BMGeneric *self); void bpy_bm_generic_invalidate(BPy_BMGeneric *self); +void *bpy_bm_generic_py_seq_as_array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_ssize_t max, Py_ssize_t *r_size, + PyTypeObject *type, + const char do_unique_check, const char do_bm_check, + const char *error_prefix); + #define BPY_BM_CHECK_OBJ(obj) if (bpy_bm_generic_valid_check((BPy_BMGeneric *)obj) == -1) { return NULL; } (void)NULL #define BPY_BM_CHECK_INT(obj) if (bpy_bm_generic_valid_check((BPy_BMGeneric *)obj) == -1) { return -1; } (void)NULL diff --git a/source/blender/python/bmesh/bmesh_py_utils.c b/source/blender/python/bmesh/bmesh_py_utils.c index 21a033f135f..52bffe968e2 100644 --- a/source/blender/python/bmesh/bmesh_py_utils.c +++ b/source/blender/python/bmesh/bmesh_py_utils.c @@ -378,6 +378,42 @@ static PyObject *bpy_bm_utils_face_split(PyObject *UNUSED(self), PyObject *args) } } +PyDoc_STRVAR(bpy_bm_utils_face_join_doc, +".. method:: face_join(faces)\n" +"\n" +" Joins a sequence of faces.\n" +"\n" +" :arg faces: Sequence of faces .\n" +" :type faces: :class:`bmesh.tupes.BMFace`\n" +" :return: The newly created face or None on failier.\n" +" :rtype: :class:`bmesh.tupes.BMFace`\n" +); +static PyObject *bpy_bm_utils_face_join(PyObject *UNUSED(self), PyObject *value) +{ + BMesh *bm = NULL; + BMFace **face_array; + Py_ssize_t face_seq_len = 0; + BMFace *f_new; + + face_array = bpy_bm_generic_py_seq_as_array(&bm, value, 2, PY_SSIZE_T_MAX, + &face_seq_len, &BPy_BMFace_Type, + TRUE, TRUE, "face_join(...)"); + + if (face_array == NULL) { + return NULL; /* error will be set */ + } + + /* Go ahead and join the face! + * --------------------------- */ + f_new = BM_faces_join(bm, face_array, (int)face_seq_len); + + if (f_new) { + return BPy_BMFace_CreatePyObject(bm, f_new); + } + else { + Py_RETURN_NONE; + } +} static struct PyMethodDef BPy_BM_utils_methods[] = { {"vert_collapse_edge", (PyCFunction)bpy_bm_utils_vert_collapse_edge, METH_VARARGS, bpy_bm_utils_vert_collapse_edge_doc}, @@ -386,6 +422,7 @@ static struct PyMethodDef BPy_BM_utils_methods[] = { {"edge_split", (PyCFunction)bpy_bm_utils_edge_split, METH_VARARGS, bpy_bm_utils_edge_split_doc}, {"edge_rotate", (PyCFunction)bpy_bm_utils_edge_rotate, METH_VARARGS, bpy_bm_utils_edge_rotate_doc}, {"face_split", (PyCFunction)bpy_bm_utils_face_split, METH_VARARGS, bpy_bm_utils_face_split_doc}, + {"face_join", (PyCFunction)bpy_bm_utils_face_join, METH_O, bpy_bm_utils_face_join_doc}, {NULL, NULL, 0, NULL} }; -- cgit v1.2.3