Mesh Operators¶

bpy.ops.mesh.beautify_fill(angle_limit=3.14159)¶

Rearrange some faces to try to get less degenerated geometry

Parameters:	angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit

bpy.ops.mesh.bevel(offset_type='OFFSET', offset=0.0, segments=1, profile=0.5, vertex_only=False, clamp_overlap=False, loop_slide=True, material=-1)¶

Edge Bevel

Parameters:

offset_type (enum in ['OFFSET', 'WIDTH', 'DEPTH', 'PERCENT'], (optional)) –
Amount Type, What distance Amount measures
- OFFSET Offset, Amount is offset of new edges from original.
- WIDTH Width, Amount is width of new face.
- DEPTH Depth, Amount is perpendicular distance from original edge to bevel face.
- PERCENT Percent, Amount is percent of adjacent edge length.
offset (float in [-1e+06, 1e+06], (optional)) – Amount
segments (int in [1, 1000], (optional)) – Segments, Segments for curved edge
profile (float in [0, 1], (optional)) – Profile, Controls profile shape (0.5 = round)
vertex_only (boolean, (optional)) – Vertex Only, Bevel only vertices
clamp_overlap (boolean, (optional)) – Clamp Overlap, Do not allow beveled edges/vertices to overlap each other
loop_slide (boolean, (optional)) – Loop Slide, Prefer slide along edge to even widths
material (int in [-1, inf], (optional)) – Material, Material for bevel faces (-1 means use adjacent faces)

bpy.ops.mesh.bisect(plane_co=(0.0, 0.0, 0.0), plane_no=(0.0, 0.0, 0.0), use_fill=False, clear_inner=False, clear_outer=False, threshold=0.0001, xstart=0, xend=0, ystart=0, yend=0, cursor=1002)¶

Cut geometry along a plane (click-drag to define plane)

Parameters:

plane_co (float array of 3 items in [-inf, inf], (optional)) – Plane Point, A point on the plane
plane_no (float array of 3 items in [-1, 1], (optional)) – Plane Normal, The direction the plane points
use_fill (boolean, (optional)) – Fill, Fill in the cut
clear_inner (boolean, (optional)) – Clear Inner, Remove geometry behind the plane
clear_outer (boolean, (optional)) – Clear Outer, Remove geometry in front of the plane
threshold (float in [0, 10], (optional)) – Axis Threshold, Preserves the existing geometry along the cut plane
xstart (int in [-inf, inf], (optional)) – X Start
xend (int in [-inf, inf], (optional)) – X End
ystart (int in [-inf, inf], (optional)) – Y Start
yend (int in [-inf, inf], (optional)) – Y End
cursor (int in [0, inf], (optional)) – Cursor, Mouse cursor style to use during the modal operator

bpy.ops.mesh.blend_from_shape(shape='', blend=1.0, add=True)¶

Blend in shape from a shape key

Parameters:	shape (enum in [], (optional)) – Shape, Shape key to use for blending blend (float in [-1000, 1000], (optional)) – Blend, Blending factor add (boolean, (optional)) – Add, Add rather than blend between shapes

bpy.ops.mesh.bridge_edge_loops(type='SINGLE', use_merge=False, merge_factor=0.5, twist_offset=0, number_cuts=0, interpolation='PATH', smoothness=1.0, profile_shape_factor=0.0, profile_shape='SMOOTH')¶

Make faces between two or more edge loops

Parameters:

type (enum in ['SINGLE', 'CLOSED', 'PAIRS'], (optional)) – Connect Loops, Method of bridging multiple loops
use_merge (boolean, (optional)) – Merge, Merge rather than creating faces
merge_factor (float in [0, 1], (optional)) – Merge Factor
twist_offset (int in [-1000, 1000], (optional)) – Twist, Twist offset for closed loops
number_cuts (int in [0, 1000], (optional)) – Number of Cuts
interpolation (enum in ['LINEAR', 'PATH', 'SURFACE'], (optional)) – Interpolation, Interpolation method
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
profile_shape_factor (float in [-1000, 1000], (optional)) – Profile Factor, How much intermediary new edges are shrunk/expanded
profile_shape (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –
Profile Shape, Shape of the profile
- SMOOTH Smooth, Smooth falloff.
- SPHERE Sphere, Spherical falloff.
- ROOT Root, Root falloff.
- INVERSE_SQUARE Inverse Square, Inverse Square falloff.
- SHARP Sharp, Sharp falloff.
- LINEAR Linear, Linear falloff.

bpy.ops.mesh.colors_reverse()¶: Flip direction of vertex colors inside faces

bpy.ops.mesh.colors_rotate(use_ccw=False)¶

Rotate vertex colors inside faces

Parameters:	use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.customdata_custom_splitnormals_add()¶: Add a custom split normals layer, if none exists yet

bpy.ops.mesh.customdata_custom_splitnormals_clear()¶: Remove the custom split normals layer, if it exists

bpy.ops.mesh.customdata_mask_clear()¶: Clear vertex sculpt masking data from the mesh

bpy.ops.mesh.customdata_skin_add()¶: Add a vertex skin layer

bpy.ops.mesh.customdata_skin_clear()¶: Clear vertex skin layer

bpy.ops.mesh.decimate(ratio=1.0, use_vertex_group=False, vertex_group_factor=1.0, invert_vertex_group=False, use_symmetry=False, symmetry_axis='Y')¶

Simplify geometry by collapsing edges

Parameters:

ratio (float in [0, 1], (optional)) – Ratio
use_vertex_group (boolean, (optional)) – Vertex Group, Use active vertex group as an influence
vertex_group_factor (float in [0, 1000], (optional)) – Weight, Vertex group strength
invert_vertex_group (boolean, (optional)) – Invert, Invert vertex group influence
use_symmetry (boolean, (optional)) – Symmetry, Maintain symmetry on an axis
symmetry_axis (enum in ['X', 'Y', 'Z'], (optional)) – Axis, Axis of symmetry

bpy.ops.mesh.delete(type='VERT')¶

Delete selected vertices, edges or faces

Parameters:	type (enum in ['VERT', 'EDGE', 'FACE', 'EDGE_FACE', 'ONLY_FACE'], (optional)) – Type, Method used for deleting mesh data

bpy.ops.mesh.delete_edgeloop(use_face_split=True)¶

Delete an edge loop by merging the faces on each side

Parameters:	use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.delete_loose(use_verts=True, use_edges=True, use_faces=False)¶

Delete loose vertices, edges or faces

Parameters:	use_verts (boolean, (optional)) – Vertices, Remove loose vertices use_edges (boolean, (optional)) – Edges, Remove loose edges use_faces (boolean, (optional)) – Faces, Remove loose faces

bpy.ops.mesh.dissolve_degenerate(threshold=0.0001)¶

Dissolve zero area faces and zero length edges

Parameters:	threshold (float in [1e-06, 50], (optional)) – Merge Distance, Minimum distance between elements to merge

bpy.ops.mesh.dissolve_edges(use_verts=True, use_face_split=False)¶

Dissolve edges, merging faces

Parameters:	use_verts (boolean, (optional)) – Dissolve Verts, Dissolve remaining vertices use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.dissolve_faces(use_verts=False)¶

Dissolve faces

Parameters:	use_verts (boolean, (optional)) – Dissolve Verts, Dissolve remaining vertices

bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665, use_dissolve_boundaries=False, delimit={'NORMAL'})¶

Dissolve selected edges and verts, limited by the angle of surrounding geometry

Parameters:

angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit
use_dissolve_boundaries (boolean, (optional)) – All Boundaries, Dissolve all vertices inbetween face boundaries
delimit (enum set in {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) –
Delimit, Delimit dissolve operation
- NORMAL Normal, Delimit by face directions.
- MATERIAL Material, Delimit by face material.
- SEAM Seam, Delimit by edge seams.
- SHARP Sharp, Delimit by sharp edges.
- UV UVs, Delimit by UV coordinates.

bpy.ops.mesh.dissolve_mode(use_verts=False, use_face_split=False, use_boundary_tear=False)¶

Dissolve geometry based on the selection mode

Parameters:	use_verts (boolean, (optional)) – Dissolve Verts, Dissolve remaining vertices use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry use_boundary_tear (boolean, (optional)) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.dissolve_verts(use_face_split=False, use_boundary_tear=False)¶

Dissolve verts, merge edges and faces

Parameters:	use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry use_boundary_tear (boolean, (optional)) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.drop_named_image(name="Image", filepath="Path", relative_path=True)¶

Assign Image to active UV Map, or create an UV Map

Parameters:	name (string, (optional, never None)) – Name, Image name to assign filepath (string, (optional, never None)) – Filepath, Path to image file relative_path (boolean, (optional)) – Relative Path, Select the file relative to the blend file

bpy.ops.mesh.dupli_extrude_cursor(rotate_source=True)¶

Duplicate and extrude selected vertices, edges or faces towards the mouse cursor

Parameters:	rotate_source (boolean, (optional)) – Rotate Source, Rotate initial selection giving better shape

bpy.ops.mesh.duplicate(mode=1)¶

Duplicate selected vertices, edges or faces

Parameters:	mode (int in [0, inf], (optional)) – Mode

bpy.ops.mesh.duplicate_move(MESH_OT_duplicate=None, TRANSFORM_OT_translate=None)¶

Duplicate mesh and move

Parameters:	MESH_OT_duplicate (`MESH_OT_duplicate`, (optional)) – Duplicate, Duplicate selected vertices, edges or faces TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.edge_collapse()¶: Collapse selected edges

bpy.ops.mesh.edge_face_add()¶: Add an edge or face to selected

bpy.ops.mesh.edge_rotate(use_ccw=False)¶

Rotate selected edge or adjoining faces

Parameters:	use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.edge_split()¶: Split selected edges so that each neighbor face gets its own copy

bpy.ops.mesh.edgering_select(extend=False, deselect=False, toggle=False, ring=True)¶

Select an edge ring

Parameters:	extend (boolean, (optional)) – Extend, Extend the selection deselect (boolean, (optional)) – Deselect, Remove from the selection toggle (boolean, (optional)) – Toggle Select, Toggle the selection ring (boolean, (optional)) – Select Ring, Select ring

bpy.ops.mesh.edges_select_sharp(sharpness=0.523599)¶

Select all sharp-enough edges

Parameters:	sharpness (float in [0.000174533, 3.14159], (optional)) – Sharpness

bpy.ops.mesh.extrude_edges_indiv(mirror=False)¶

Extrude individual edges only

Parameters:	mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_edges_move(MESH_OT_extrude_edges_indiv=None, TRANSFORM_OT_translate=None)¶

Extrude edges and move result

Parameters:	MESH_OT_extrude_edges_indiv (`MESH_OT_extrude_edges_indiv`, (optional)) – Extrude Only Edges, Extrude individual edges only TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.extrude_faces_indiv(mirror=False)¶

Extrude individual faces only

Parameters:	mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_faces_move(MESH_OT_extrude_faces_indiv=None, TRANSFORM_OT_shrink_fatten=None)¶

Extrude faces and move result

Parameters:	MESH_OT_extrude_faces_indiv (`MESH_OT_extrude_faces_indiv`, (optional)) – Extrude Individual Faces, Extrude individual faces only TRANSFORM_OT_shrink_fatten (`TRANSFORM_OT_shrink_fatten`, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_region(mirror=False)¶

Extrude region of faces

Parameters:	mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region=None, TRANSFORM_OT_translate=None)¶

Extrude region and move result

Parameters:	MESH_OT_extrude_region (`MESH_OT_extrude_region`, (optional)) – Extrude Region, Extrude region of faces TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.extrude_region_shrink_fatten(MESH_OT_extrude_region=None, TRANSFORM_OT_shrink_fatten=None)¶

Extrude region and move result

Parameters:	MESH_OT_extrude_region (`MESH_OT_extrude_region`, (optional)) – Extrude Region, Extrude region of faces TRANSFORM_OT_shrink_fatten (`TRANSFORM_OT_shrink_fatten`, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_repeat(offset=2.0, steps=10)¶

Extrude selected vertices, edges or faces repeatedly

Parameters:	offset (float in [0, inf], (optional)) – Offset steps (int in [0, 1000000], (optional)) – Steps

bpy.ops.mesh.extrude_vertices_move(MESH_OT_extrude_verts_indiv=None, TRANSFORM_OT_translate=None)¶

Extrude vertices and move result

Parameters:	MESH_OT_extrude_verts_indiv (`MESH_OT_extrude_verts_indiv`, (optional)) – Extrude Only Vertices, Extrude individual vertices only TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.extrude_verts_indiv(mirror=False)¶

Extrude individual vertices only

Parameters:	mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.face_make_planar(factor=1.0, repeat=1)¶

Flatten selected faces

Parameters:	factor (float in [-10, 10], (optional)) – Factor repeat (int in [1, 10000], (optional)) – Iterations

bpy.ops.mesh.face_split_by_edges()¶: Weld loose edges into faces (splitting them into new faces)

bpy.ops.mesh.faces_mirror_uv(direction='POSITIVE', precision=3)¶

Copy mirror UV coordinates on the X axis based on a mirrored mesh

Parameters:	direction (enum in ['POSITIVE', 'NEGATIVE'], (optional)) – Axis Direction precision (int in [1, 16], (optional)) – Precision, Tolerance for finding vertex duplicates
File:	startup/bl_operators/mesh.py:57

bpy.ops.mesh.faces_select_linked_flat(sharpness=0.0174533)¶

Select linked faces by angle

Parameters:	sharpness (float in [0.000174533, 3.14159], (optional)) – Sharpness

bpy.ops.mesh.faces_shade_flat()¶: Display faces flat

bpy.ops.mesh.faces_shade_smooth()¶: Display faces smooth (using vertex normals)

bpy.ops.mesh.fill(use_beauty=True)¶

Fill a selected edge loop with faces

Parameters:	use_beauty (boolean, (optional)) – Beauty, Use best triangulation division

bpy.ops.mesh.fill_grid(span=1, offset=0, use_interp_simple=False)¶

Fill grid from two loops

Parameters:	span (int in [1, 1000], (optional)) – Span, Number of grid columns offset (int in [-1000, 1000], (optional)) – Offset, Vertex that is the corner of the grid use_interp_simple (boolean, (optional)) – Simple Blending, Use simple interpolation of grid vertices

bpy.ops.mesh.fill_holes(sides=4)¶

Fill in holes (boundary edge loops)

Parameters:	sides (int in [0, 1000], (optional)) – Sides, Number of sides in hole required to fill (zero fills all holes)

bpy.ops.mesh.flip_normals()¶: Flip the direction of selected faces’ normals (and of their vertices)

bpy.ops.mesh.hide(unselected=False)¶

Hide (un)selected vertices, edges or faces

Parameters:	unselected (boolean, (optional)) – Unselected, Hide unselected rather than selected

bpy.ops.mesh.inset(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_edge_rail=False, thickness=0.01, depth=0.0, use_outset=False, use_select_inset=False, use_individual=False, use_interpolate=True)¶

Inset new faces into selected faces

Parameters:

use_boundary (boolean, (optional)) – Boundary, Inset face boundaries
use_even_offset (boolean, (optional)) – Offset Even, Scale the offset to give more even thickness
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
use_edge_rail (boolean, (optional)) – Edge Rail, Inset the region along existing edges
thickness (float in [0, inf], (optional)) – Thickness
depth (float in [-inf, inf], (optional)) – Depth
use_outset (boolean, (optional)) – Outset, Outset rather than inset
use_select_inset (boolean, (optional)) – Select Outer, Select the new inset faces
use_individual (boolean, (optional)) – Individual, Individual Face Inset
use_interpolate (boolean, (optional)) – Interpolate, Blend face data across the inset

bpy.ops.mesh.intersect(mode='SELECT_UNSELECT', separate_mode='CUT', threshold=1e-06)¶

Cut an intersection into faces

Parameters:

mode (enum in ['SELECT', 'SELECT_UNSELECT'], (optional)) –
Source
- SELECT Self Intersect, Self intersect selected faces.
- SELECT_UNSELECT Selected/Unselected, Intersect selected with unselected faces.
separate_mode (enum in ['ALL', 'CUT', 'NONE'], (optional)) –
Separate Mode
- ALL All, Separate all geometry from intersections.
- CUT Cut, Cut into geometry keeping each side separate (Selected/Unselected only).
- NONE Merge, Merge all geometry from the intersection.
threshold (float in [0, 0.01], (optional)) – Merge threshold

bpy.ops.mesh.intersect_boolean(operation='DIFFERENCE', use_swap=False, threshold=1e-06)¶

Cut solid geometry from selected to unselected

Parameters:	operation (enum in ['INTERSECT', 'UNION', 'DIFFERENCE'], (optional)) – Boolean use_swap (boolean, (optional)) – Swap, Use with difference intersection to swap which side is kept threshold (float in [0, 0.01], (optional)) – Merge threshold

bpy.ops.mesh.knife_project(cut_through=False)¶

Use other objects outlines & boundaries to project knife cuts

Parameters:	cut_through (boolean, (optional)) – Cut through, Cut through all faces, not just visible ones

bpy.ops.mesh.knife_tool(use_occlude_geometry=True, only_selected=False, wait_for_input=True)¶

Cut new topology

Parameters:	use_occlude_geometry (boolean, (optional)) – Occlude Geometry, Only cut the front most geometry only_selected (boolean, (optional)) – Only Selected, Only cut selected geometry wait_for_input (boolean, (optional)) – Wait for Input

bpy.ops.mesh.loop_multi_select(ring=False)¶

Select a loop of connected edges by connection type

Parameters:	ring (boolean, (optional)) – Ring

bpy.ops.mesh.loop_select(extend=False, deselect=False, toggle=False, ring=False)¶

Select a loop of connected edges

Parameters:	extend (boolean, (optional)) – Extend Select, Extend the selection deselect (boolean, (optional)) – Deselect, Remove from the selection toggle (boolean, (optional)) – Toggle Select, Toggle the selection ring (boolean, (optional)) – Select Ring, Select ring

bpy.ops.mesh.loop_to_region(select_bigger=False)¶

Select region of faces inside of a selected loop of edges

Parameters:	select_bigger (boolean, (optional)) – Select Bigger, Select bigger regions instead of smaller ones

bpy.ops.mesh.loopcut(number_cuts=1, smoothness=0.0, falloff='INVERSE_SQUARE', edge_index=-1, mesh_select_mode_init=(False, False, False))¶

Add a new loop between existing loops

Parameters:

number_cuts (int in [1, 1000000], (optional)) – Number of Cuts
smoothness (float in [-1000, 1000], (optional)) – Smoothness, Smoothness factor
falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –
Falloff, Falloff type the feather
- SMOOTH Smooth, Smooth falloff.
- SPHERE Sphere, Spherical falloff.
- ROOT Root, Root falloff.
- INVERSE_SQUARE Inverse Square, Inverse Square falloff.
- SHARP Sharp, Sharp falloff.
- LINEAR Linear, Linear falloff.
edge_index (int in [-1, inf], (optional)) – Edge Index

bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut=None, TRANSFORM_OT_edge_slide=None)¶

Cut mesh loop and slide it

Parameters:	MESH_OT_loopcut (`MESH_OT_loopcut`, (optional)) – Loop Cut, Add a new loop between existing loops TRANSFORM_OT_edge_slide (`TRANSFORM_OT_edge_slide`, (optional)) – Edge Slide, Slide an edge loop along a mesh

bpy.ops.mesh.mark_seam(clear=False)¶

(Un)mark selected edges as a seam

Parameters:	clear (boolean, (optional)) – Clear

bpy.ops.mesh.mark_sharp(clear=False, use_verts=False)¶

(Un)mark selected edges as sharp

Parameters:	clear (boolean, (optional)) – Clear use_verts (boolean, (optional)) – Vertices, Consider vertices instead of edges to select which edges to (un)tag as sharp

bpy.ops.mesh.merge(type='CENTER', uvs=False)¶

Merge selected vertices

Parameters:	type (enum in ['FIRST', 'LAST', 'CENTER', 'CURSOR', 'COLLAPSE'], (optional)) – Type, Merge method to use uvs (boolean, (optional)) – UVs, Move UVs according to merge

bpy.ops.mesh.navmesh_clear()¶: Remove navmesh data from this mesh

bpy.ops.mesh.navmesh_face_add()¶: Add a new index and assign it to selected faces

bpy.ops.mesh.navmesh_face_copy()¶: Copy the index from the active face

bpy.ops.mesh.navmesh_make()¶: Create navigation mesh for selected objects

bpy.ops.mesh.navmesh_reset()¶: Assign a new index to every face

bpy.ops.mesh.noise(factor=0.1)¶

Use vertex coordinate as texture coordinate

Parameters:	factor (float in [-10000, 10000], (optional)) – Factor

bpy.ops.mesh.normals_make_consistent(inside=False)¶

Make face and vertex normals point either outside or inside the mesh

Parameters:	inside (boolean, (optional)) – Inside

bpy.ops.mesh.offset_edge_loops(use_cap_endpoint=False)¶

Create offset edge loop from the current selection

Parameters:	use_cap_endpoint (boolean, (optional)) – Cap Endpoint, Extend loop around end-points

bpy.ops.mesh.offset_edge_loops_slide(MESH_OT_offset_edge_loops=None, TRANSFORM_OT_edge_slide=None)¶

Offset edge loop slide

Parameters:	MESH_OT_offset_edge_loops (`MESH_OT_offset_edge_loops`, (optional)) – Offset Edge Loop, Create offset edge loop from the current selection TRANSFORM_OT_edge_slide (`TRANSFORM_OT_edge_slide`, (optional)) – Edge Slide, Slide an edge loop along a mesh

bpy.ops.mesh.poke(offset=0.0, use_relative_offset=False, center_mode='MEAN_WEIGHTED')¶

Split a face into a fan

Parameters:

offset (float in [-1000, 1000], (optional)) – Poke Offset, Poke Offset
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
center_mode (enum in ['MEAN_WEIGHTED', 'MEAN', 'BOUNDS'], (optional)) –
Poke Center, Poke Face Center Calculation
- MEAN_WEIGHTED Weighted Mean, Weighted Mean Face Center.
- MEAN Mean, Mean Face Center.
- BOUNDS Bounds, Face Bounds Center.

bpy.ops.mesh.primitive_circle_add(vertices=32, radius=1.0, fill_type='NOTHING', calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a circle mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius (float in [0, inf], (optional)) – Radius
fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Fill Type
- NOTHING Nothing, Don’t fill at all.
- NGON Ngon, Use ngons.
- TRIFAN Triangle Fan, Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_cone_add(vertices=32, radius1=1.0, radius2=0.0, depth=2.0, end_fill_type='NGON', calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a conic mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius1 (float in [0, inf], (optional)) – Radius 1
radius2 (float in [0, inf], (optional)) – Radius 2
depth (float in [0, inf], (optional)) – Depth
end_fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Base Fill Type
- NOTHING Nothing, Don’t fill at all.
- NGON Ngon, Use ngons.
- TRIFAN Triangle Fan, Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_cube_add(radius=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a cube mesh

Parameters:

radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_cylinder_add(vertices=32, radius=1.0, depth=2.0, end_fill_type='NGON', calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a cylinder mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius (float in [0, inf], (optional)) – Radius
depth (float in [0, inf], (optional)) – Depth
end_fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Cap Fill Type
- NOTHING Nothing, Don’t fill at all.
- NGON Ngon, Use ngons.
- TRIFAN Triangle Fan, Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_grid_add(x_subdivisions=10, y_subdivisions=10, radius=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a grid mesh

Parameters:

x_subdivisions (int in [2, 10000000], (optional)) – X Subdivisions
y_subdivisions (int in [2, 10000000], (optional)) – Y Subdivisions
radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=2, size=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct an Icosphere mesh

Parameters:

subdivisions (int in [1, 10], (optional)) – Subdivisions
size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_monkey_add(radius=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a Suzanne mesh

Parameters:

radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_plane_add(radius=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a filled planar mesh with 4 vertices

Parameters:

radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.primitive_torus_add(view_align=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False), major_segments=48, minor_segments=12, mode='MAJOR_MINOR', major_radius=1.0, minor_radius=0.25, abso_major_rad=1.25, abso_minor_rad=0.75, generate_uvs=False)¶

Add a torus mesh

Parameters:

view_align (boolean, (optional)) – Align to View
location (float array of 3 items in [-inf, inf], (optional)) – Location
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation
layers (boolean array of 20 items, (optional)) – Layers
major_segments (int in [3, 256], (optional)) – Major Segments, Number of segments for the main ring of the torus
minor_segments (int in [3, 256], (optional)) – Minor Segments, Number of segments for the minor ring of the torus
mode (enum in ['MAJOR_MINOR', 'EXT_INT'], (optional)) –
Torus Dimensions
- MAJOR_MINOR Major/Minor, Use the major/minor radii for torus dimensions.
- EXT_INT Exterior/Interior, Use the exterior/interior radii for torus dimensions.
major_radius (float in [0.01, 100], (optional)) – Major Radius, Radius from the origin to the center of the cross sections
minor_radius (float in [0.01, 100], (optional)) – Minor Radius, Radius of the torus’ cross section
abso_major_rad (float in [0.01, 100], (optional)) – Exterior Radius, Total Exterior Radius of the torus
abso_minor_rad (float in [0.01, 100], (optional)) – Interior Radius, Total Interior Radius of the torus
generate_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map

File:

startup/bl_operators/add_mesh_torus.py:245

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16, size=1.0, calc_uvs=False, view_align=False, enter_editmode=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))¶

Construct a UV sphere mesh

Parameters:

segments (int in [3, 100000], (optional)) – Segments
ring_count (int in [3, 100000], (optional)) – Rings
size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
view_align (boolean, (optional)) – Align to View, Align the new object to the view
enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object
location (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
layers (boolean array of 20 items, (optional)) – Layer

bpy.ops.mesh.quads_convert_to_tris(quad_method='BEAUTY', ngon_method='BEAUTY')¶

Triangulate selected faces

Parameters:

quad_method (enum in ['BEAUTY', 'FIXED', 'FIXED_ALTERNATE', 'SHORTEST_DIAGONAL'], (optional)) –
Quad Method, Method for splitting the quads into triangles
- BEAUTY Beauty , Split the quads in nice triangles, slower method.
- FIXED Fixed, Split the quads on the first and third vertices.
- FIXED_ALTERNATE Fixed Alternate, Split the quads on the 2nd and 4th vertices.
- SHORTEST_DIAGONAL Shortest Diagonal, Split the quads based on the distance between the vertices.
ngon_method (enum in ['BEAUTY', 'CLIP'], (optional)) –
Polygon Method, Method for splitting the polygons into triangles
- BEAUTY Beauty, Arrange the new triangles evenly (slow).
- CLIP Clip, Split the polygons with an ear clipping algorithm.

bpy.ops.mesh.region_to_loop()¶: Select boundary edges around the selected faces

bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False)¶

Remove duplicate vertices

Parameters:	threshold (float in [1e-06, 50], (optional)) – Merge Distance, Minimum distance between elements to merge use_unselected (boolean, (optional)) – Unselected, Merge selected to other unselected vertices

bpy.ops.mesh.reveal(select=True)¶

Reveal all hidden vertices, edges and faces

Parameters:	select (boolean, (optional)) – Select

bpy.ops.mesh.rip(mirror=False, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1.0, release_confirm=False, use_accurate=False, use_fill=False)¶

Disconnect vertex or edges from connected geometry

Parameters:

mirror (boolean, (optional)) – Mirror Editing
proportional (enum in ['DISABLED', 'ENABLED', 'PROJECTED', 'CONNECTED'], (optional)) –
Proportional Editing
- DISABLED Disable, Proportional Editing disabled.
- ENABLED Enable, Proportional Editing enabled.
- PROJECTED Projected (2D), Proportional Editing using screen space locations.
- CONNECTED Connected, Proportional Editing using connected geometry only.
proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –
Proportional Editing Falloff, Falloff type for proportional editing mode
- SMOOTH Smooth, Smooth falloff.
- SPHERE Sphere, Spherical falloff.
- ROOT Root, Root falloff.
- INVERSE_SQUARE Inverse Square, Inverse Square falloff.
- SHARP Sharp, Sharp falloff.
- LINEAR Linear, Linear falloff.
- CONSTANT Constant, Constant falloff.
- RANDOM Random, Random falloff.
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation
use_fill (boolean, (optional)) – Fill, Fill the ripped region

bpy.ops.mesh.rip_edge(mirror=False, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1.0, release_confirm=False, use_accurate=False)¶

Extend vertices along the edge closest to the cursor

Parameters:

mirror (boolean, (optional)) – Mirror Editing
proportional (enum in ['DISABLED', 'ENABLED', 'PROJECTED', 'CONNECTED'], (optional)) –
Proportional Editing
- DISABLED Disable, Proportional Editing disabled.
- ENABLED Enable, Proportional Editing enabled.
- PROJECTED Projected (2D), Proportional Editing using screen space locations.
- CONNECTED Connected, Proportional Editing using connected geometry only.
proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –
Proportional Editing Falloff, Falloff type for proportional editing mode
- SMOOTH Smooth, Smooth falloff.
- SPHERE Sphere, Spherical falloff.
- ROOT Root, Root falloff.
- INVERSE_SQUARE Inverse Square, Inverse Square falloff.
- SHARP Sharp, Sharp falloff.
- LINEAR Linear, Linear falloff.
- CONSTANT Constant, Constant falloff.
- RANDOM Random, Random falloff.
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.rip_edge_move(MESH_OT_rip_edge=None, TRANSFORM_OT_translate=None)¶

Extend vertices and move the result

Parameters:	MESH_OT_rip_edge (`MESH_OT_rip_edge`, (optional)) – Extend Vertices, Extend vertices along the edge closest to the cursor TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.rip_move(MESH_OT_rip=None, TRANSFORM_OT_translate=None)¶

Rip polygons and move the result

Parameters:	MESH_OT_rip (`MESH_OT_rip`, (optional)) – Rip, Disconnect vertex or edges from connected geometry TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Translate, Translate (move) selected items

bpy.ops.mesh.screw(steps=9, turns=1, center=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 0.0))¶

Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport

Parameters:	steps (int in [1, 100000], (optional)) – Steps, Steps turns (int in [1, 100000], (optional)) – Turns, Turns center (float array of 3 items in [-inf, inf], (optional)) – Center, Center in global view space axis (float array of 3 items in [-1, 1], (optional)) – Axis, Axis in global view space

bpy.ops.mesh.select_all(action='TOGGLE')¶

(De)select all vertices, edges or faces

Parameters:

action (enum in ['TOGGLE', 'SELECT', 'DESELECT', 'INVERT'], (optional)) –

Action, Selection action to execute

TOGGLE Toggle, Toggle selection for all elements.
SELECT Select, Select all elements.
DESELECT Deselect, Deselect all elements.
INVERT Invert, Invert selection of all elements.

bpy.ops.mesh.select_axis(mode='POSITIVE', axis='X_AXIS', threshold=0.0001)¶

Select all data in the mesh on a single axis

Parameters:	mode (enum in ['POSITIVE', 'NEGATIVE', 'ALIGNED'], (optional)) – Axis Mode, Axis side to use when selecting axis (enum in ['X_AXIS', 'Y_AXIS', 'Z_AXIS'], (optional)) – Axis, Select the axis to compare each vertex on threshold (float in [1e-06, 50], (optional)) – Threshold

bpy.ops.mesh.select_face_by_sides(number=4, type='EQUAL', extend=True)¶

Select vertices or faces by the number of polygon sides

Parameters:	number (int in [3, inf], (optional)) – Number of Vertices type (enum in ['LESS', 'EQUAL', 'GREATER', 'NOTEQUAL'], (optional)) – Type, Type of comparison to make extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.select_interior_faces()¶: Select faces where all edges have more than 2 face users

bpy.ops.mesh.select_less(use_face_step=True)¶

Deselect vertices, edges or faces at the boundary of each selection region

Parameters:	use_face_step (boolean, (optional)) – Face Step, Connected faces (instead of edges)

bpy.ops.mesh.select_linked(delimit={'SEAM'})¶

Select all vertices connected to the current selection

Parameters:

delimit (enum set in {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) –

Delimit, Delimit selected region

NORMAL Normal, Delimit by face directions.
MATERIAL Material, Delimit by face material.
SEAM Seam, Delimit by edge seams.
SHARP Sharp, Delimit by sharp edges.
UV UVs, Delimit by UV coordinates.

bpy.ops.mesh.select_linked_pick(deselect=False, delimit={'SEAM'}, index=-1)¶

(De)select all vertices linked to the edge under the mouse cursor

Parameters:	deselect (boolean, (optional)) – Deselect delimit (enum set in {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) – Delimit, Delimit selected region `NORMAL` Normal, Delimit by face directions. `MATERIAL` Material, Delimit by face material. `SEAM` Seam, Delimit by edge seams. `SHARP` Sharp, Delimit by sharp edges. `UV` UVs, Delimit by UV coordinates.

bpy.ops.mesh.select_loose(extend=False)¶

Select loose geometry based on the selection mode

Parameters:	extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.select_mirror(axis={'X'}, extend=False)¶

Select mesh items at mirrored locations

Parameters:	axis (enum set in {'X', 'Y', 'Z'}, (optional)) – Axis extend (boolean, (optional)) – Extend, Extend the existing selection

bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='VERT', action='TOGGLE')¶

Change selection mode

Parameters:

use_extend (boolean, (optional)) – Extend
use_expand (boolean, (optional)) – Expand
type (enum in ['VERT', 'EDGE', 'FACE'], (optional)) – Type
action (enum in ['DISABLE', 'ENABLE', 'TOGGLE'], (optional)) –
Action, Selection action to execute
- DISABLE Disable, Disable selected markers.
- ENABLE Enable, Enable selected markers.
- TOGGLE Toggle, Toggle disabled flag for selected markers.

bpy.ops.mesh.select_more(use_face_step=True)¶

Select more vertices, edges or faces connected to initial selection

Parameters:	use_face_step (boolean, (optional)) – Face Step, Connected faces (instead of edges)

bpy.ops.mesh.select_next_item()¶

Select the next element (using selection order)

File:	startup/bl_operators/mesh.py:168

bpy.ops.mesh.select_non_manifold(extend=True, use_wire=True, use_boundary=True, use_multi_face=True, use_non_contiguous=True, use_verts=True)¶

Select all non-manifold vertices or edges

Parameters:

extend (boolean, (optional)) – Extend, Extend the selection
use_wire (boolean, (optional)) – Wire, Wire edges
use_boundary (boolean, (optional)) – Boundaries, Boundary edges
use_multi_face (boolean, (optional)) – Multiple Faces, Edges shared by 3+ faces
use_non_contiguous (boolean, (optional)) – Non Contiguous, Edges between faces pointing in alternate directions
use_verts (boolean, (optional)) – Vertices, Vertices connecting multiple face regions

bpy.ops.mesh.select_nth(nth=2, skip=1, offset=0)¶

Deselect every Nth element starting from the active vertex, edge or face

Parameters:	nth (int in [2, inf], (optional)) – Nth Element, Skip every Nth element skip (int in [1, inf], (optional)) – Skip, Number of elements to skip at once offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.select_prev_item()¶

Select the previous element (using selection order)

File:	startup/bl_operators/mesh.py:193

bpy.ops.mesh.select_random(percent=50.0, seed=0, action='SELECT')¶

Randomly select vertices

Parameters:	percent (float in [0, 100], (optional)) – Percent, Percentage of objects to select randomly seed (int in [0, inf], (optional)) – Random Seed, Seed for the random number generator action (enum in ['SELECT', 'DESELECT'], (optional)) – Action, Selection action to execute `SELECT` Select, Select all elements. `DESELECT` Deselect, Deselect all elements.

bpy.ops.mesh.select_similar(type='NORMAL', compare='EQUAL', threshold=0.0)¶

Select similar vertices, edges or faces by property types

Parameters:

type (enum in ['NORMAL', 'FACE', 'VGROUP', 'EDGE', 'LENGTH', 'DIR', 'FACE', 'FACE_ANGLE', 'CREASE', 'BEVEL', 'SEAM', 'SHARP', 'MATERIAL', 'IMAGE', 'AREA', 'SIDES', 'PERIMETER', 'NORMAL', 'COPLANAR', 'SMOOTH'], (optional)) – Type
compare (enum in ['EQUAL', 'GREATER', 'LESS'], (optional)) – Compare
threshold (float in [0, 1], (optional)) – Threshold

bpy.ops.mesh.select_similar_region()¶: Select similar face regions to the current selection

bpy.ops.mesh.select_ungrouped(extend=False)¶

Select vertices without a group

Parameters:	extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.separate(type='SELECTED')¶

Separate selected geometry into a new mesh

Parameters:	type (enum in ['SELECTED', 'MATERIAL', 'LOOSE'], (optional)) – Type

bpy.ops.mesh.set_normals_from_faces()¶

Set the custom vertex normals from the selected faces ones

File:	startup/bl_operators/mesh.py:220

bpy.ops.mesh.shape_propagate_to_all()¶: Apply selected vertex locations to all other shape keys

bpy.ops.mesh.shortest_path_pick(use_face_step=False, use_topology_distance=False, use_fill=False, nth=1, skip=1, offset=0, index=-1)¶

Select shortest path between two selections

Parameters:

use_face_step (boolean, (optional)) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
use_topology_distance (boolean, (optional)) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
use_fill (boolean, (optional)) – Fill Region, Select all paths between the source/destination elements
nth (int in [1, inf], (optional)) – Nth Element, Skip every Nth element
skip (int in [1, inf], (optional)) – Skip, Number of elements to skip at once
offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.shortest_path_select(use_face_step=False, use_topology_distance=False, use_fill=False, nth=1, skip=1, offset=0)¶

Selected shortest path between two vertices/edges/faces

Parameters:

use_face_step (boolean, (optional)) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
use_topology_distance (boolean, (optional)) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
use_fill (boolean, (optional)) – Fill Region, Select all paths between the source/destination elements
nth (int in [1, inf], (optional)) – Nth Element, Skip every Nth element
skip (int in [1, inf], (optional)) – Skip, Number of elements to skip at once
offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.solidify(thickness=0.01)¶

Create a solid skin by extruding, compensating for sharp angles

Parameters:	thickness (float in [-10000, 10000], (optional)) – Thickness

bpy.ops.mesh.sort_elements(type='VIEW_ZAXIS', elements={'VERT'}, reverse=False, seed=0)¶

The order of selected vertices/edges/faces is modified, based on a given method

Parameters:

type (enum in ['VIEW_ZAXIS', 'VIEW_XAXIS', 'CURSOR_DISTANCE', 'MATERIAL', 'SELECTED', 'RANDOMIZE', 'REVERSE'], (optional)) –
Type, Type of re-ordering operation to apply
- VIEW_ZAXIS View Z Axis, Sort selected elements from farthest to nearest one in current view.
- VIEW_XAXIS View X Axis, Sort selected elements from left to right one in current view.
- CURSOR_DISTANCE Cursor Distance, Sort selected elements from nearest to farthest from 3D cursor.
- MATERIAL Material, Sort selected elements from smallest to greatest material index (faces only!).
- SELECTED Selected, Move all selected elements in first places, preserving their relative order (WARNING: this will affect unselected elements’ indices as well!).
- RANDOMIZE Randomize, Randomize order of selected elements.
- REVERSE Reverse, Reverse current order of selected elements.
elements (enum set in {'VERT', 'EDGE', 'FACE'}, (optional)) – Elements, Which elements to affect (vertices, edges and/or faces)
reverse (boolean, (optional)) – Reverse, Reverse the sorting effect
seed (int in [0, inf], (optional)) – Seed, Seed for random-based operations

bpy.ops.mesh.spin(steps=9, dupli=False, angle=1.5708, center=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 0.0))¶

Extrude selected vertices in a circle around the cursor in indicated viewport

Parameters:

steps (int in [0, 1000000], (optional)) – Steps, Steps
dupli (boolean, (optional)) – Dupli, Make Duplicates
angle (float in [-inf, inf], (optional)) – Angle, Rotation for each step
center (float array of 3 items in [-inf, inf], (optional)) – Center, Center in global view space
axis (float array of 3 items in [-1, 1], (optional)) – Axis, Axis in global view space

bpy.ops.mesh.split()¶: Split off selected geometry from connected unselected geometry

bpy.ops.mesh.subdivide(number_cuts=1, smoothness=0.0, quadtri=False, quadcorner='STRAIGHT_CUT', fractal=0.0, fractal_along_normal=0.0, seed=0)¶

Subdivide selected edges

Parameters:

number_cuts (int in [1, 100], (optional)) – Number of Cuts
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
quadtri (boolean, (optional)) – Quad/Tri Mode, Tries to prevent ngons
quadcorner (enum in ['INNERVERT', 'PATH', 'STRAIGHT_CUT', 'FAN'], (optional)) – Quad Corner Type, How to subdivide quad corners (anything other than Straight Cut will prevent ngons)
fractal (float in [0, 1e+06], (optional)) – Fractal, Fractal randomness factor
fractal_along_normal (float in [0, 1], (optional)) – Along Normal, Apply fractal displacement along normal only
seed (int in [0, inf], (optional)) – Random Seed, Seed for the random number generator

bpy.ops.mesh.subdivide_edgering(number_cuts=10, interpolation='PATH', smoothness=1.0, profile_shape_factor=0.0, profile_shape='SMOOTH')¶

Undocumented

Parameters:

number_cuts (int in [0, 1000], (optional)) – Number of Cuts
interpolation (enum in ['LINEAR', 'PATH', 'SURFACE'], (optional)) – Interpolation, Interpolation method
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
profile_shape_factor (float in [-1000, 1000], (optional)) – Profile Factor, How much intermediary new edges are shrunk/expanded
profile_shape (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –
Profile Shape, Shape of the profile
- SMOOTH Smooth, Smooth falloff.
- SPHERE Sphere, Spherical falloff.
- ROOT Root, Root falloff.
- INVERSE_SQUARE Inverse Square, Inverse Square falloff.
- SHARP Sharp, Sharp falloff.
- LINEAR Linear, Linear falloff.

bpy.ops.mesh.symmetrize(direction='NEGATIVE_X', threshold=0.0001)¶

Enforce symmetry (both form and topological) across an axis

Parameters:	direction (enum in ['NEGATIVE_X', 'POSITIVE_X', 'NEGATIVE_Y', 'POSITIVE_Y', 'NEGATIVE_Z', 'POSITIVE_Z'], (optional)) – Direction, Which sides to copy from and to threshold (float in [0, 10], (optional)) – Threshold, Limit for snap middle vertices to the axis center

bpy.ops.mesh.symmetry_snap(direction='NEGATIVE_X', threshold=0.05, factor=0.5, use_center=True)¶

Snap vertex pairs to their mirrored locations

Parameters:

direction (enum in ['NEGATIVE_X', 'POSITIVE_X', 'NEGATIVE_Y', 'POSITIVE_Y', 'NEGATIVE_Z', 'POSITIVE_Z'], (optional)) – Direction, Which sides to copy from and to
threshold (float in [0, 10], (optional)) – Threshold, Distance within which matching vertices are searched
factor (float in [0, 1], (optional)) – Factor, Mix factor of the locations of the vertices
use_center (boolean, (optional)) – Center, Snap middle vertices to the axis center

bpy.ops.mesh.tris_convert_to_quads(face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=False, sharp=False, materials=False)¶

Join triangles into quads

Parameters:

face_threshold (float in [0, 3.14159], (optional)) – Max Face Angle, Face angle limit
shape_threshold (float in [0, 3.14159], (optional)) – Max Shape Angle, Shape angle limit
uvs (boolean, (optional)) – Compare UVs
vcols (boolean, (optional)) – Compare VCols
seam (boolean, (optional)) – Compare Seam
sharp (boolean, (optional)) – Compare Sharp
materials (boolean, (optional)) – Compare Materials

bpy.ops.mesh.unsubdivide(iterations=2)¶

UnSubdivide selected edges & faces

Parameters:	iterations (int in [1, 1000], (optional)) – Iterations, Number of times to unsubdivide

bpy.ops.mesh.uv_texture_add()¶: Add UV Map

bpy.ops.mesh.uv_texture_remove()¶: Remove UV Map

bpy.ops.mesh.uvs_reverse()¶: Flip direction of UV coordinates inside faces

bpy.ops.mesh.uvs_rotate(use_ccw=False)¶

Rotate UV coordinates inside faces

Parameters:	use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.vert_connect()¶: Connect selected vertices of faces, splitting the face

bpy.ops.mesh.vert_connect_concave()¶: Make all faces convex

bpy.ops.mesh.vert_connect_nonplanar(angle_limit=0.0872665)¶

Split non-planar faces that exceed the angle threshold

Parameters:	angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit

bpy.ops.mesh.vert_connect_path()¶: Connect vertices by their selection order, creating edges, splitting faces

bpy.ops.mesh.vertex_color_add()¶: Add vertex color layer

bpy.ops.mesh.vertex_color_remove()¶: Remove vertex color layer

bpy.ops.mesh.vertices_smooth(factor=0.5, repeat=1, xaxis=True, yaxis=True, zaxis=True)¶

Flatten angles of selected vertices

Parameters:	factor (float in [-10, 10], (optional)) – Smoothing, Smoothing factor repeat (int in [1, 1000], (optional)) – Repeat, Number of times to smooth the mesh xaxis (boolean, (optional)) – X-Axis, Smooth along the X axis yaxis (boolean, (optional)) – Y-Axis, Smooth along the Y axis zaxis (boolean, (optional)) – Z-Axis, Smooth along the Z axis

bpy.ops.mesh.vertices_smooth_laplacian(repeat=1, lambda_factor=5e-05, lambda_border=5e-05, use_x=True, use_y=True, use_z=True, preserve_volume=True)¶

Laplacian smooth of selected vertices

Parameters:

repeat (int in [1, 1000], (optional)) – Number of iterations to smooth the mesh
lambda_factor (float in [1e-07, 1000], (optional)) – Lambda factor
lambda_border (float in [1e-07, 1000], (optional)) – Lambda factor in border
use_x (boolean, (optional)) – Smooth X Axis, Smooth object along X axis
use_y (boolean, (optional)) – Smooth Y Axis, Smooth object along Y axis
use_z (boolean, (optional)) – Smooth Z Axis, Smooth object along Z axis
preserve_volume (boolean, (optional)) – Preserve Volume, Apply volume preservation after smooth

bpy.ops.mesh.wireframe(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_replace=True, thickness=0.01, offset=0.01, use_crease=False, crease_weight=0.01)¶

Create a solid wire-frame from faces

Parameters:

use_boundary (boolean, (optional)) – Boundary, Inset face boundaries
use_even_offset (boolean, (optional)) – Offset Even, Scale the offset to give more even thickness
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
use_replace (boolean, (optional)) – Replace, Remove original faces
thickness (float in [0, 10000], (optional)) – Thickness
offset (float in [0, 10000], (optional)) – Offset
use_crease (boolean, (optional)) – Crease, Crease hub edges for improved subsurf
crease_weight (float in [0, 1000], (optional)) – Crease weight

Mesh Operators¶

Previous topic

Next topic