# BMesh Operators (bmesh.ops)

This module gives access to low level bmesh operations.

Most operators take input and return output, they can be chained together to perform useful operations.

Note

This API us new in 2.65 and not yet well tested.

## Operator Example

This script shows how operators can be used to model a link of a chain.

    # This script uses bmesh operators to make 2 links of a chain.

    import bpy
    import bmesh
    import math
    import mathutils

    # Make a new BMesh
    bm = bmesh.new()

    # Add a circle XXX, should return all geometry created, not just verts.
    bmesh.ops.create_circle(
            bm,
            cap_ends=False,
            diameter=0.2,
            segments=8)

    # Spin and deal with geometry on side 'a'
    edges_start_a = bm.edges[:]
    geom_start_a = bm.verts[:] + edges_start_a
    ret = bmesh.ops.spin(
            bm,
            geom=geom_start_a,
            angle=math.radians(180.0),
            steps=8,
            axis=(1.0, 0.0, 0.0),
            cent=(0.0, 1.0, 0.0))
    edges_end_a = [ele for ele in ret["geom_last"]
                   if isinstance(ele, bmesh.types.BMEdge)]
    del ret

    # Extrude and create geometry on side 'b'
    ret = bmesh.ops.extrude_edge_only(
            bm,
            edges=edges_start_a)
    geom_extrude_mid = ret["geom"]
    del ret

    # Collect the edges to spin XXX, 'extrude_edge_only' could return this.
    verts_extrude_b = [ele for ele in geom_extrude_mid
                       if isinstance(ele, bmesh.types.BMVert)]
    edges_extrude_b = [ele for ele in geom_extrude_mid
                       if isinstance(ele, bmesh.types.BMEdge) and ele.is_boundary]
    bmesh.ops.translate(
            bm,
            verts=verts_extrude_b,
            vec=(0.0, 0.0, 1.0))

    # Create the circle on side 'b'
    ret = bmesh.ops.spin(
            bm,
            geom=verts_extrude_b + edges_extrude_b,
            angle=-math.radians(180.0),
            steps=8,
            axis=(1.0, 0.0, 0.0),
            cent=(0.0, 1.0, 1.0))
    edges_end_b = [ele for ele in ret["geom_last"]
                   if isinstance(ele, bmesh.types.BMEdge)]
    del ret

    # Bridge the resulting edge loops of both spins 'a & b'
    bmesh.ops.bridge_loops(
            bm,
            edges=edges_end_a + edges_end_b)

    # Now we have made a links of the chain, make a copy and rotate it
    # (so this looks something like a chain)

    ret = bmesh.ops.duplicate(
            bm,
            geom=bm.verts[:] + bm.edges[:] + bm.faces[:])
    geom_dupe = ret["geom"]
    verts_dupe = [ele for ele in geom_dupe if isinstance(ele, bmesh.types.BMVert)]
    del ret

    # position the new link
    bmesh.ops.translate(
            bm,
            verts=verts_dupe,
            vec=(0.0, 0.0, 2.0))
    bmesh.ops.rotate(
            bm,
            verts=verts_dupe,
            cent=(0.0, 1.0, 0.0),
            matrix=mathutils.Matrix.Rotation(math.radians(90.0), 3, 'Z'))

    # Done with creating the mesh, simply link it into the scene so we can see it

    # Finish up, write the bmesh into a new mesh
    me = bpy.data.meshes.new("Mesh")
    bm.to_mesh(me)
    bm.free()

    # Add the mesh to the scene
    scene = bpy.context.scene
    obj = bpy.data.objects.new("Object", me)
    scene.objects.link(obj)

    # Select and make active
    scene.objects.active = obj
    obj.select = True

`bmesh.ops.``smooth_vert`(bm, verts, factor, mirror_clip_x, mirror_clip_y, mirror_clip_z, clip_dist, use_axis_x, use_axis_y, use_axis_z)

  Vertex Smooth.

  Smooths vertices by using a basic vertex averaging scheme.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices factor (float) – smoothing factor mirror_clip_x (bool) – set vertices close to the x axis before the operation to 0 mirror_clip_y (bool) – set vertices close to the y axis before the operation to 0 mirror_clip_z (bool) – set vertices close to the z axis before the operation to 0 clip_dist (float) – clipping threshold for the above three slots use_axis_x (bool) – smooth vertices along X axis use_axis_y (bool) – smooth vertices along Y axis use_axis_z (bool) – smooth vertices along Z axis

`bmesh.ops.``smooth_laplacian_vert`(bm, verts, lambda_factor, lambda_border, use_x, use_y, use_z, preserve_volume)

  Vertext Smooth Laplacian.

  Smooths vertices by using Laplacian smoothing propose by. Desbrun, et al. Implicit Fairing of Irregular Meshes using Diffusion and Curvature Flow.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices lambda_factor (float) – lambda param lambda_border (float) – lambda param in border use_x (bool) – Smooth object along X axis use_y (bool) – Smooth object along Y axis use_z (bool) – Smooth object along Z axis preserve_volume (bool) – Apply volume preservation after smooth

`bmesh.ops.``recalc_face_normals`(bm, faces)

  Right-Hand Faces.

  Computes an “outside” normal for the specified input faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – Undocumented.

`bmesh.ops.``planar_faces`(bm, faces, iterations, factor)

  Planar Faces.

  Iteratively flatten faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input geometry. iterations (int) – Undocumented. factor (float) – planar factor
  Returns: | `geom`: output slot, computed boundary geometry. type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``region_extend`(bm, geom, use_contract, use_faces, use_face_step)

  Region Extend.

  used to implement the select more/less tools. this puts some geometry surrounding regions of geometry in geom into geom.out.

  if use_faces is 0 then geom.out spits out verts and edges, otherwise it spits out faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – input geometry use_contract (bool) – find boundary inside the regions, not outside. use_faces (bool) – extend from faces instead of edges use_face_step (bool) – step over connected faces
  Returns: | `geom`: output slot, computed boundary geometry. type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``rotate_edges`(bm, edges, use_ccw)

  Edge Rotate.

  Rotates edges topologically. Also known as “spin edge” to some people. Simple example: `[/] becomes [|] then [\]`.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges use_ccw (bool) – rotate edge counter-clockwise if true, otherwise clockwise
  Returns: | `edges`: newly spun edges type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``reverse_faces`(bm, faces)

  Reverse Faces.

  Reverses the winding (vertex order) of faces. This has the effect of flipping the normal.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces

`bmesh.ops.``bisect_edges`(bm, edges, cuts, edge_percents)

  Edge Bisect.

  Splits input edges (but doesn’t do anything else). This creates a 2-valence vert.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges cuts (int) – number of cuts edge_percents (dict mapping vert/edge/face types to float) – Undocumented.
  Returns: | `geom_split`: newly created vertices and edges type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``mirror`(bm, geom, matrix, merge_dist, axis, mirror_u, mirror_v)

  Mirror.

  Mirrors geometry along an axis. The resulting geometry is welded on using merge_dist. Pairs of original/mirrored vertices are welded using the merge_dist parameter (which defines the minimum distance for welding to happen).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – input geometry matrix (`mathutils.Matrix`) – matrix defining the mirror transformation merge_dist (float) – maximum distance for merging. does no merging if 0. axis (int) – the axis to use, 0, 1, or 2 for x, y, z mirror_u (bool) – mirror UVs across the u axis mirror_v (bool) – mirror UVs across the v axis
  Returns: | `geom`: output geometry, mirrored type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``find_doubles`(bm, verts, keep_verts, dist)

  Find Doubles.

  Takes input verts and find vertices they should weld to. Outputs a mapping slot suitable for use with the weld verts bmop.

  If keep_verts is used, vertices outside that set can only be merged with vertices in that set.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices keep_verts (list of (`bmesh.types.BMVert`)) – list of verts to keep dist (float) – minimum distance
  Returns: | `targetmap`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
  Return type: | dict with string keys

`bmesh.ops.``remove_doubles`(bm, verts, dist)

  Remove Doubles.

  Finds groups of vertices closer then dist and merges them together, using the weld verts bmop.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input verts dist (float) – minimum distance

`bmesh.ops.``automerge`(bm, verts, dist)

  Auto Merge.

  Finds groups of vertices closer then dist and merges them together, using the weld verts bmop. The merges must go from a vert not in verts to one in verts.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input verts dist (float) – minimum distance

`bmesh.ops.``collapse`(bm, edges, uvs)

  Collapse Connected.

  Collapses connected vertices

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges uvs (bool) – also collapse UVs and such

`bmesh.ops.``pointmerge_facedata`(bm, verts, vert_snap)

  Face-Data Point Merge.

  Merge uv/vcols at a specific vertex.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices vert_snap (`bmesh.types.BMVert`) – snap vertex

`bmesh.ops.``average_vert_facedata`(bm, verts)

  Average Vertices Facevert Data.

  Merge uv/vcols associated with the input vertices at the bounding box center. (I know, it’s not averaging but the vert_snap_to_bb_center is just too long).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices

`bmesh.ops.``pointmerge`(bm, verts, merge_co)

  Point Merge.

  Merge verts together at a point.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices merge_co (`mathutils.Vector` or any sequence of 3 floats) – Undocumented.

`bmesh.ops.``collapse_uvs`(bm, edges)

  Collapse Connected UV’s.

  Collapses connected UV vertices.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges

`bmesh.ops.``weld_verts`(bm, targetmap)

  Weld Verts.

  Welds verts together (kind-of like remove doubles, merge, etc, all of which use or will use this bmop). You pass in mappings from vertices to the vertices they weld with.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. targetmap (dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`) – Undocumented.

`bmesh.ops.``create_vert`(bm, co)

  Make Vertex.

  Creates a single vertex; this bmop was necessary for click-create-vertex.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. co (`mathutils.Vector` or any sequence of 3 floats) – the coordinate of the new vert
  Returns: | `vert`: the new vert type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``join_triangles`(bm, faces, cmp_seam, cmp_sharp, cmp_uvs, cmp_vcols, cmp_materials, angle_face_threshold, angle_shape_threshold)

  Join Triangles.

  Tries to intelligently join triangles according to angle threshold and delimiters.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input geometry. cmp_seam (bool) – Undocumented. cmp_sharp (bool) – Undocumented. cmp_uvs (bool) – Undocumented. cmp_vcols (bool) – Undocumented. cmp_materials (bool) – Undocumented. angle_face_threshold (float) – Undocumented. angle_shape_threshold (float) – Undocumented.
  Returns: | `faces`: joined faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``contextual_create`(bm, geom, mat_nr, use_smooth)

  Contextual Create.

  This is basically F-key, it creates new faces from vertices, makes stuff from edge nets, makes wire edges, etc. It also dissolves faces.

  Three verts become a triangle, four become a quad. Two become a wire edge.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – input geometry. mat_nr (int) – material to use use_smooth (bool) – smooth to use
  Returns: | `faces`: newly-made face(s) type list of (`bmesh.types.BMFace`) `edges`: newly-made edge(s) type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``bridge_loops`(bm, edges, use_pairs, use_cyclic, use_merge, merge_factor, twist_offset)

  Bridge edge loops with faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges use_pairs (bool) – Undocumented. use_cyclic (bool) – Undocumented. use_merge (bool) – Undocumented. merge_factor (float) – Undocumented. twist_offset (int) – Undocumented.
  Returns: | `faces`: new faces type list of (`bmesh.types.BMFace`) `edges`: new edges type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``grid_fill`(bm, edges, mat_nr, use_smooth, use_interp_simple)

  Grid Fill.

  Create faces defined by 2 disconnected edge loops (which share edges).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges mat_nr (int) – material to use use_smooth (bool) – smooth state to use use_interp_simple (bool) – use simple interpolation
  Returns: | `faces`: new faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``holes_fill`(bm, edges, sides)

  Fill Holes.

  Fill boundary edges with faces, copying surrounding customdata.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges sides (int) – number of face sides to fill
  Returns: | `faces`: new faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``face_attribute_fill`(bm, faces, use_normals, use_data)

  Face Attribute Fill.

  Fill in faces with data from adjacent faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces use_normals (bool) – copy face winding use_data (bool) – copy face data
  Returns: | `faces_fail`: faces that could not be handled type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``edgeloop_fill`(bm, edges, mat_nr, use_smooth)

  Edge Loop Fill.

  Create faces defined by one or more non overlapping edge loops.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges mat_nr (int) – material to use use_smooth (bool) – smooth state to use
  Returns: | `faces`: new faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``edgenet_fill`(bm, edges, mat_nr, use_smooth, sides)

  Edge Net Fill.

  Create faces defined by enclosed edges.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges mat_nr (int) – material to use use_smooth (bool) – smooth state to use sides (int) – number of sides
  Returns: | `faces`: new faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``edgenet_prepare`(bm, edges)

  Edgenet Prepare.

  Identifies several useful edge loop cases and modifies them so they’ll become a face when edgenet_fill is called. The cases covered are:

  - One single loop; an edge is added to connect the ends
  - Two loops; two edges are added to connect the endpoints (based on the shortest distance between each endpont).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges
  Returns: | `edges`: new edges type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``rotate`(bm, cent, matrix, verts, space)

  Rotate.

  Rotate vertices around a center, using a 3x3 rotation matrix.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. cent (`mathutils.Vector` or any sequence of 3 floats) – center of rotation matrix (`mathutils.Matrix`) – matrix defining rotation verts (list of (`bmesh.types.BMVert`)) – input vertices space (`mathutils.Matrix`) – matrix to define the space (typically object matrix)

`bmesh.ops.``translate`(bm, vec, space, verts)

  Translate.

  Translate vertices by an offset.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. vec (`mathutils.Vector` or any sequence of 3 floats) – translation offset space (`mathutils.Matrix`) – matrix to define the space (typically object matrix) verts (list of (`bmesh.types.BMVert`)) – input vertices

`bmesh.ops.``scale`(bm, vec, space, verts)

  Scale.

  Scales vertices by an offset.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. vec (`mathutils.Vector` or any sequence of 3 floats) – scale factor space (`mathutils.Matrix`) – matrix to define the space (typically object matrix) verts (list of (`bmesh.types.BMVert`)) – input vertices

`bmesh.ops.``transform`(bm, matrix, space, verts)

  Transform.

  Transforms a set of vertices by a matrix. Multiplies the vertex coordinates with the matrix.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. matrix (`mathutils.Matrix`) – transform matrix space (`mathutils.Matrix`) – matrix to define the space (typically object matrix) verts (list of (`bmesh.types.BMVert`)) – input vertices

`bmesh.ops.``object_load_bmesh`(bm, scene, object)

  Object Load BMesh.

  Loads a bmesh into an object/mesh. This is a “private” bmop.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. scene (`bpy.types.Scene`) – Undocumented. object (`bpy.types.Object`) – Undocumented.

`bmesh.ops.``bmesh_to_mesh`(bm, mesh, object, skip_tessface)

  BMesh to Mesh.

  Converts a bmesh to a Mesh. This is reserved for exiting editmode.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. mesh (`bpy.types.Mesh`) – Undocumented. object (`bpy.types.Object`) – Undocumented. skip_tessface (bool) – don’t calculate mfaces

`bmesh.ops.``mesh_to_bmesh`(bm, mesh, object, use_shapekey)

  Mesh to BMesh.

  Load the contents of a mesh into the bmesh. this bmop is private, it’s reserved exclusively for entering editmode.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. mesh (`bpy.types.Mesh`) – Undocumented. object (`bpy.types.Object`) – Undocumented. use_shapekey (bool) – load active shapekey coordinates into verts

`bmesh.ops.``extrude_discrete_faces`(bm, faces, use_select_history)

  Individual Face Extrude.

  Extrudes faces individually.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces use_select_history (bool) – pass to duplicate
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``extrude_edge_only`(bm, edges, use_select_history)

  Extrude Only Edges.

  Extrudes Edges into faces, note that this is very simple, there’s no fancy winged extrusion.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input vertices use_select_history (bool) – pass to duplicate
  Returns: | `geom`: output geometry type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``extrude_vert_indiv`(bm, verts, use_select_history)

  Individual Vertex Extrude.

  Extrudes wire edges from vertices.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices use_select_history (bool) – pass to duplicate
  Returns: | `edges`: output wire edges type list of (`bmesh.types.BMEdge`) `verts`: output vertices type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``connect_verts`(bm, verts, faces_exclude, check_degenerate)

  Connect Verts.

  Split faces by adding edges that connect verts.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – Undocumented. faces_exclude (list of (`bmesh.types.BMFace`)) – Undocumented. check_degenerate (bool) – prevent splits with overlaps & intersections
  Returns: | `edges`: type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``connect_verts_concave`(bm, faces)

  Connect Verts to form Convex Faces.

  Ensures all faces are convex faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – Undocumented.
  Returns: | `edges`: type list of (`bmesh.types.BMEdge`) `faces`: type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``connect_verts_nonplanar`(bm, angle_limit, faces)

  Connect Verts Across non Planer Faces.

  Split faces by connecting edges along non planer faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. angle_limit (float) – total rotation angle (radians) faces (list of (`bmesh.types.BMFace`)) – Undocumented.
  Returns: | `edges`: type list of (`bmesh.types.BMEdge`) `faces`: type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``connect_vert_pair`(bm, verts, verts_exclude, faces_exclude)

  Connect Verts.

  Split faces by adding edges that connect verts.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – Undocumented. verts_exclude (list of (`bmesh.types.BMVert`)) – Undocumented. faces_exclude (list of (`bmesh.types.BMFace`)) – Undocumented.
  Returns: | `edges`: type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``extrude_face_region`(bm, geom, edges_exclude, use_keep_orig, use_select_history)

  Extrude Faces.

  Extrude operator (does not transform)

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – edges and faces edges_exclude (set of vert/edge/face type) – Undocumented. use_keep_orig (bool) – keep original geometry use_select_history (bool) – pass to duplicate
  Returns: | `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``dissolve_verts`(bm, verts, use_face_split, use_boundary_tear)

  Dissolve Verts.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – Undocumented. use_face_split (bool) – Undocumented. use_boundary_tear (bool) – Undocumented.

`bmesh.ops.``dissolve_edges`(bm, edges, use_verts, use_face_split)

  Dissolve Edges.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – Undocumented. use_verts (bool) – dissolve verts left between only 2 edges. use_face_split (bool) – Undocumented.
  Returns: | `region`: type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``dissolve_faces`(bm, faces, use_verts)

  Dissolve Faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – Undocumented. use_verts (bool) – dissolve verts left between only 2 edges.
  Returns: | `region`: type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``dissolve_limit`(bm, angle_limit, use_dissolve_boundaries, verts, edges, delimit)

  Limited Dissolve.

  Dissolve planar faces and co-linear edges.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. angle_limit (float) – total rotation angle (radians) use_dissolve_boundaries (bool) – Undocumented. verts (list of (`bmesh.types.BMVert`)) – Undocumented. edges (list of (`bmesh.types.BMEdge`)) – Undocumented. delimit (int) – Undocumented.
  Returns: | `region`: type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``dissolve_degenerate`(bm, dist, edges)

  Degenerate Dissolve.

  Dissolve edges with no length, faces with no area.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. dist (float) – minimum distance to consider degenerate edges (list of (`bmesh.types.BMEdge`)) – Undocumented.

`bmesh.ops.``triangulate`(bm, faces, quad_method, ngon_method)

  Triangulate.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – Undocumented. quad_method (int) – Undocumented. ngon_method (int) – Undocumented.
  Returns: | `edges`: type list of (`bmesh.types.BMEdge`) `faces`: type list of (`bmesh.types.BMFace`) `face_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `face_map_double`: duplicate faces type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
  Return type: | dict with string keys

`bmesh.ops.``unsubdivide`(bm, verts, iterations)

  Un-Subdivide.

  Reduce detail in geometry containing grids.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices iterations (int) – Undocumented.

`bmesh.ops.``subdivide_edges`(bm, edges, smooth, smooth_falloff, fractal, along_normal, cuts, seed, custom_patterns, edge_percents, quad_corner_type, use_grid_fill, use_single_edge, use_only_quads, use_sphere, use_smooth_even)

  Subdivide Edges.

  Advanced operator for subdividing edges with options for face patterns, smoothing and randomization.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – Undocumented. smooth (float) – Undocumented. smooth_falloff (int) – SUBD_FALLOFF_ROOT and friends fractal (float) – Undocumented. along_normal (float) – Undocumented. cuts (int) – Undocumented. seed (int) – Undocumented. custom_patterns (dict mapping vert/edge/face types to unknown internal data, not compatible with python) – uses custom pointers edge_percents (dict mapping vert/edge/face types to float) – Undocumented. quad_corner_type (int) – quad corner type, see bmesh_operators.h use_grid_fill (bool) – fill in fully-selected faces with a grid use_single_edge (bool) – tessellate the case of one edge selected in a quad or triangle use_only_quads (bool) – only subdivide quads (for loopcut) use_sphere (bool) – for making new primitives only use_smooth_even (bool) – maintain even offset when smoothing
  Returns: | `geom_inner`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom_split`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom`: contains all output geometry type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``subdivide_edgering`(bm, edges, interp_mode, smooth, cuts, profile_shape, profile_shape_factor)

  Subdivide Edge-Ring.

  Take an edge-ring, and subdivide with interpolation options.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input vertices interp_mode (int) – Undocumented. smooth (float) – Undocumented. cuts (int) – Undocumented. profile_shape (int) – Undocumented. profile_shape_factor (float) – Undocumented.
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``bisect_plane`(bm, geom, dist, plane_co, plane_no, use_snap_center, clear_outer, clear_inner)

  Bisect Plane.

  Bisects the mesh by a plane (cut the mesh in half).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. dist (float) – minimum distance when testing if a vert is exactly on the plane plane_co (`mathutils.Vector` or any sequence of 3 floats) – point on the plane plane_no (`mathutils.Vector` or any sequence of 3 floats) – direction of the plane use_snap_center (bool) – snap axis aligned verts to the center clear_outer (bool) – when enabled. remove all geometry on the positive side of the plane clear_inner (bool) – when enabled. remove all geometry on the negative side of the plane
  Returns: | `geom_cut`: output new geometry from the cut type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`) `geom`: input and output geometry (result of cut) type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``delete`(bm, geom, context)

  Delete Geometry.

  Utility operator to delete geometry.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. context (int) – enum DEL_VERTS ...

`bmesh.ops.``duplicate`(bm, geom, dest, use_select_history)

  Duplicate Geometry.

  Utility operator to duplicate geometry, optionally into a destination mesh.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. dest (`bmesh.types.BMesh`) – Undocumented. use_select_history (bool) – Undocumented.
  Returns: | `geom_orig`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `vert_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `edge_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `face_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `boundary_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `isovert_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
  Return type: | dict with string keys

`bmesh.ops.``split`(bm, geom, dest, use_only_faces)

  Split Off Geometry.

  Disconnect geometry from adjacent edges and faces, optionally into a destination mesh.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. dest (`bmesh.types.BMesh`) – Undocumented. use_only_faces (bool) – when enabled. don’t duplicate loose verts/edges
  Returns: | `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `boundary_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace` `isovert_map`: type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
  Return type: | dict with string keys

`bmesh.ops.``spin`(bm, geom, cent, axis, dvec, angle, space, steps, use_duplicate)

  Spin.

  Extrude or duplicate geometry a number of times, rotating and possibly translating after each step

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. cent (`mathutils.Vector` or any sequence of 3 floats) – rotation center axis (`mathutils.Vector` or any sequence of 3 floats) – rotation axis dvec (`mathutils.Vector` or any sequence of 3 floats) – translation delta per step angle (float) – total rotation angle (radians) space (`mathutils.Matrix`) – matrix to define the space (typically object matrix) steps (int) – number of steps use_duplicate (bool) – duplicate or extrude?
  Returns: | `geom_last`: result of last step type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``similar_faces`(bm, faces, type, thresh, compare)

  Similar Faces Search.

  Find similar faces (area/material/perimeter, ...).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces type (int) – type of selection thresh (float) – threshold of selection compare (int) – comparison method
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``similar_edges`(bm, edges, type, thresh, compare)

  Similar Edges Search.

  > Find similar edges (length, direction, edge, seam, ...).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges type (int) – type of selection thresh (float) – threshold of selection compare (int) – comparison method
  Returns: | `edges`: output edges type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``similar_verts`(bm, verts, type, thresh, compare)

  Similar Verts Search.

  Find similar vertices (normal, face, vertex group, ...).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. verts (list of (`bmesh.types.BMVert`)) – input vertices type (int) – type of selection thresh (float) – threshold of selection compare (int) – comparison method
  Returns: | `verts`: output vertices type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``rotate_uvs`(bm, faces, use_ccw)

  UV Rotation.

  Cycle the loop UV’s

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces use_ccw (bool) – rotate counter-clockwise if true, otherwise clockwise

`bmesh.ops.``reverse_uvs`(bm, faces)

  UV Reverse.

  Reverse the UV’s

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces

`bmesh.ops.``rotate_colors`(bm, faces, use_ccw)

  Color Rotation.

  Cycle the loop colors

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces use_ccw (bool) – rotate counter-clockwise if true, otherwise clockwise

`bmesh.ops.``reverse_colors`(bm, faces)

  Color Reverse

  Reverse the loop colors.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces

`bmesh.ops.``split_edges`(bm, edges, verts, use_verts)

  Edge Split.

  Disconnects faces along input edges.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input edges verts (list of (`bmesh.types.BMVert`)) – optional tag verts, use to have greater control of splits use_verts (bool) – use ‘verts’ for splitting, else just find verts to split from edges
  Returns: | `edges`: old output disconnected edges type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``create_grid`(bm, x_segments, y_segments, size, matrix)

  Create Grid.

  Creates a grid with a variable number of subdivisions

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. x_segments (int) – number of x segments y_segments (int) – number of y segments size (float) – size of the grid matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_uvsphere`(bm, u_segments, v_segments, diameter, matrix)

  Create UV Sphere.

  Creates a grid with a variable number of subdivisions

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. u_segments (int) – number of u segments v_segments (int) – number of v segment diameter (float) – diameter matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_icosphere`(bm, subdivisions, diameter, matrix)

  Create Ico-Sphere.

  Creates a grid with a variable number of subdivisions

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. subdivisions (int) – how many times to recursively subdivide the sphere diameter (float) – diameter matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_monkey`(bm, matrix)

  Create Suzanne.

  Creates a monkey (standard blender primitive).

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_cone`(bm, cap_ends, cap_tris, segments, diameter1, diameter2, depth, matrix)

  Create Cone.

  Creates a cone with variable depth at both ends

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. cap_ends (bool) – whether or not to fill in the ends with faces cap_tris (bool) – fill ends with triangles instead of ngons segments (int) – Undocumented. diameter1 (float) – diameter of one end diameter2 (float) – diameter of the opposite depth (float) – distance between ends matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_circle`(bm, cap_ends, cap_tris, segments, diameter, matrix)

  Creates a Circle.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. cap_ends (bool) – whether or not to fill in the ends with faces cap_tris (bool) – fill ends with triangles instead of ngons segments (int) – Undocumented. diameter (float) – diameter of one end matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``create_cube`(bm, size, matrix)

  Create Cube

  Creates a cube.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. size (float) – size of the cube matrix (`mathutils.Matrix`) – matrix to multiply the new geometry with
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`)
  Return type: | dict with string keys

`bmesh.ops.``bevel`(bm, geom, offset, offset_type, segments, profile, vertex_only, clamp_overlap, material, loop_slide)

  Bevel.

  Bevels edges and vertices

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – input edges and vertices offset (float) – amount to offset beveled edge offset_type (int) – how to measure offset (enum) segments (int) – number of segments in bevel profile (float) – profile shape, 0->1 (.5=>round) vertex_only (bool) – only bevel vertices, not edges clamp_overlap (bool) – do not allow beveled edges/vertices to overlap each other material (int) – material for bevel faces, -1 means get from adjacent faces loop_slide (bool) – prefer to slide along edges to having even widths
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``beautify_fill`(bm, faces, edges, use_restrict_tag, method)

  Beautify Fill.

  Rotate edges to create more evenly spaced triangles.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces edges (list of (`bmesh.types.BMEdge`)) – edges that can be flipped use_restrict_tag (bool) – restrict edge rotation to mixed tagged vertices method (int) – method to define what is beautiful
  Returns: | `geom`: new flipped faces and edges type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``triangle_fill`(bm, use_beauty, use_dissolve, edges, normal)

  Triangle Fill.

  Fill edges with triangles

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. use_beauty (bool) – Undocumented. use_dissolve (bool) – dissolve resulting faces edges (list of (`bmesh.types.BMEdge`)) – input edges normal (`mathutils.Vector` or any sequence of 3 floats) – optionally pass the fill normal to use
  Returns: | `geom`: new faces and edges type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``solidify`(bm, geom, thickness)

  Solidify.

  Turns a mesh into a shell with thickness

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. geom (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. thickness (float) – Undocumented.
  Returns: | `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``inset_individual`(bm, faces, thickness, depth, use_even_offset, use_interpolate, use_relative_offset)

  Face Inset (Individual).

  Insets individual faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces thickness (float) – Undocumented. depth (float) – Undocumented. use_even_offset (bool) – Undocumented. use_interpolate (bool) – Undocumented. use_relative_offset (bool) – Undocumented.
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``inset_region`(bm, faces, faces_exclude, use_boundary, use_even_offset, use_interpolate, use_relative_offset, use_edge_rail, thickness, depth, use_outset)

  Face Inset (Regions).

  Inset or outset face regions.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces faces_exclude (list of (`bmesh.types.BMFace`)) – Undocumented. use_boundary (bool) – Undocumented. use_even_offset (bool) – Undocumented. use_interpolate (bool) – Undocumented. use_relative_offset (bool) – Undocumented. use_edge_rail (bool) – Undocumented. thickness (float) – Undocumented. depth (float) – Undocumented. use_outset (bool) – Undocumented.
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``offset_edgeloops`(bm, edges, use_cap_endpoint)

  Edgeloop Offset.

  Creates edge loops based on simple edge-outset method.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. edges (list of (`bmesh.types.BMEdge`)) – input faces use_cap_endpoint (bool) – Undocumented.
  Returns: | `edges`: output faces type list of (`bmesh.types.BMEdge`)
  Return type: | dict with string keys

`bmesh.ops.``wireframe`(bm, faces, thickness, offset, use_replace, use_boundary, use_even_offset, use_crease, crease_weight, thickness, use_relative_offset, material_offset)

  Wire Frame.

  Makes a wire-frame copy of faces.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces thickness (float) – Undocumented. offset (float) – Undocumented. use_replace (bool) – Undocumented. use_boundary (bool) – Undocumented. use_even_offset (bool) – Undocumented. use_crease (bool) – Undocumented. crease_weight (float) – Undocumented. thickness – Undocumented. use_relative_offset (bool) – Undocumented. material_offset (int) – Undocumented.
  Returns: | `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``poke`(bm, faces, offset, center_mode, use_relative_offset)

  Pokes a face.

  Splits a face into a triangle fan.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. faces (list of (`bmesh.types.BMFace`)) – input faces offset (float) – center vertex offset along normal center_mode (int) – calculation mode for center vertex use_relative_offset (bool) – apply offset
  Returns: | `verts`: output verts type list of (`bmesh.types.BMVert`) `faces`: output faces type list of (`bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``convex_hull`(bm, input, use_existing_faces)

  Convex Hull

  Builds a convex hull from the vertices in ‘input’.

  If ‘use_existing_faces’ is true, the hull will not output triangles that are covered by a pre-existing face.

  All hull vertices, faces, and edges are added to ‘geom.out’. Any input elements that end up inside the hull (i.e. are not used by an output face) are added to the ‘interior_geom’ slot. The ‘unused_geom’ slot will contain all interior geometry that is completely unused. Lastly, ‘holes_geom’ contains edges and faces that were in the input and are part of the hull.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. input (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. use_existing_faces (bool) – Undocumented.
  Returns: | `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom_interior`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom_unused`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`) `geom_holes`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys

`bmesh.ops.``symmetrize`(bm, input, direction, dist)

  Symmetrize.

  Makes the mesh elements in the “input” slot symmetrical. Unlike normal mirroring, it only copies in one direction, as specified by the “direction” slot. The edges and faces that cross the plane of symmetry are split as needed to enforce symmetry.

  All new vertices, edges, and faces are added to the “geom.out” slot.

  Parameters: | bm (`bmesh.types.BMesh`) – The bmesh to operate on. input (list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)) – Undocumented. direction (int) – Undocumented. dist (float) – minimum distance
  Returns: | `geom`: type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
  Return type: | dict with string keys