# Mesh Operators

`bpy.ops.mesh.``average_normals`(average_type='CUSTOM_NORMAL', weight=50, threshold=0.01)

  Average custom normals of selected vertices

  Parameters: | average_type (enum in ['CUSTOM_NORMAL', 'FACE_AREA', 'CORNER_ANGLE'], (optional)) – Type, Averaging method `CUSTOM_NORMAL` Custom Normal, Take Average of vert Normals. `FACE_AREA` Face Area, Set all vert normals by Face Area. `CORNER_ANGLE` Corner Angle, Set all vert normals by Corner Angle. weight (int in [1, 100], (optional)) – Weight, Weight applied per face threshold (float in [0, 10], (optional)) – Threshold, Threshold value for different weights to be considered equal

`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, offset_pct=0.0, segments=1, profile=0.5, vertex_only=False, clamp_overlap=False, loop_slide=True, mark_seam=False, mark_sharp=False, material=-1, harden_normals=False, face_strength_mode='NONE', miter_outer='SHARP', miter_inner='SHARP', spread=0.1, use_custom_profile=False, vmesh_method='ADJ', release_confirm=False)

  Cut into selected items at an angle to create bevel or chamfer

  Parameters: | offset_type (enum in ['OFFSET', 'WIDTH', 'DEPTH', 'PERCENT'], (optional)) – Width Type, What distance Width 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 [0, 1e+06], (optional)) – Width, Bevel amount offset_pct (float in [0, 100], (optional)) – Width Percent, Bevel amount for percentage method 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 sliding along edges to even widths mark_seam (boolean, (optional)) – Mark Seams, Mark Seams along beveled edges mark_sharp (boolean, (optional)) – Mark Sharp, Mark beveled edges as sharp material (int in [-1, inf], (optional)) – Material, Material for bevel faces (-1 means use adjacent faces) harden_normals (boolean, (optional)) – Harden Normals, Match normals of new faces to adjacent faces face_strength_mode (enum in ['NONE', 'NEW', 'AFFECTED', 'ALL'], (optional)) – Face Strength Mode, Whether to set face strength, and which faces to set face strength on `NONE` None, Do not set face strength. `NEW` New, Set face strength on new faces only. `AFFECTED` Affected, Set face strength on new and modified faces only. `ALL` All, Set face strength on all faces. miter_outer (enum in ['SHARP', 'PATCH', 'ARC'], (optional)) – Outer Miter, Pattern to use for outside of miters `SHARP` Sharp, Outside of miter is sharp. `PATCH` Patch, Outside of miter is squared-off patch. `ARC` Arc, Outside of miter is arc. miter_inner (enum in ['SHARP', 'ARC'], (optional)) – Inner Miter, Pattern to use for inside of miters `SHARP` Sharp, Inside of miter is sharp. `ARC` Arc, Inside of miter is arc. spread (float in [0, 1e+06], (optional)) – Spread, Amount to spread arcs for arc inner miters use_custom_profile (boolean, (optional)) – Custom Profile, Use a custom profile for the bevel vmesh_method (enum in ['ADJ', 'CUTOFF'], (optional)) – Vertex Mesh Method, The method to use to create meshes at intersections `ADJ` Grid Fill, Default patterned fill. `CUTOFF` Cutoff, A cut-off at each profile’s end before the intersection. release_confirm (boolean, (optional)) – Confirm on Release

`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=5)

  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')

  Create a bridge of faces between two or more selected 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.``convex_hull`(delete_unused=True, use_existing_faces=True, make_holes=False, join_triangles=True, face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=False, sharp=False, materials=False)

  Enclose selected vertices in a convex polyhedron

  Parameters: | delete_unused (boolean, (optional)) – Delete Unused, Delete selected elements that are not used by the hull use_existing_faces (boolean, (optional)) – Use Existing Faces, Skip hull triangles that are covered by a pre-existing face make_holes (boolean, (optional)) – Make Holes, Delete selected faces that are used by the hull join_triangles (boolean, (optional)) – Join Triangles, Merge adjacent triangles into quads 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.``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, Maximum 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 in between 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.``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)) – Move, 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_context`(use_normal_flip=False, mirror=False)

  Extrude selection

  Parameters: | use_normal_flip (boolean, (optional)) – Flip Normals mirror (boolean, (optional)) – Mirror Editing

`bpy.ops.mesh.``extrude_context_move`(MESH_OT_extrude_context=None, TRANSFORM_OT_translate=None)

  Extrude region together along the average normal

  Parameters: | MESH_OT_extrude_context (`MESH_OT_extrude_context`, (optional)) – Extrude Context, Extrude selection TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.mesh.``extrude_edges_indiv`(use_normal_flip=False, mirror=False)

  Extrude individual edges only

  Parameters: | use_normal_flip (boolean, (optional)) – Flip Normals 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)) – Move, 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 each individual face separately along local normals

  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`(use_normal_flip=False, mirror=False)

  Extrude region of faces

  Parameters: | use_normal_flip (boolean, (optional)) – Flip Normals 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)) – Move, Move selected items

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

  Extrude region together along local normals

  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)) – Move, 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:147

`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.0, depth=0.0, use_outset=False, use_select_inset=False, use_individual=False, use_interpolate=True, release_confirm=False)

  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 release_confirm (boolean, (optional)) – Confirm on Release

`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', object_index=-1, 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. object_index (int in [-1, inf], (optional)) – Object Index 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_freestyle_edge`(clear=False)

  (Un)mark selected edges as Freestyle feature edges

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

`bpy.ops.mesh.``mark_freestyle_face`(clear=False)

  (Un)mark selected faces for exclusion from Freestyle feature edge detection

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

`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.``merge_normals`()

  Merge custom normals of selected vertices

`bpy.ops.mesh.``mod_weighted_strength`(set=False, face_strength='MEDIUM')

  Set/Get strength of face (used in Weighted Normal modifier)

  Parameters: | set (boolean, (optional)) – Set value, Set Value of faces face_strength (enum in ['WEAK', 'MEDIUM', 'STRONG'], (optional)) – Face Strength, Strength to use for assigning or selecting face influence for weighted normal modifier

`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.``normals_tools`(mode='COPY', absolute=False)

  Custom normals tools using Normal Vector of UI

  Parameters: | mode (enum in ['COPY', 'PASTE', 'ADD', 'MULTIPLY', 'RESET'], (optional)) – Mode, Mode of tools taking input from Interface `COPY` Copy Normal, Copy normal to buffer. `PASTE` Paste Normal, Paste normal from buffer. `ADD` Add Normal, Add normal vector with selection. `MULTIPLY` Multiply Normal, Multiply normal vector with selection. `RESET` Reset Normal, Reset buffer and/or normal of selected element. absolute (boolean, (optional)) – Absolute Coordinates, Copy Absolute coordinates or Normal vector

`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.``paint_mask_extract`(mask_threshold=0.5, add_boundary_loop=True, smooth_iterations=4, apply_shrinkwrap=True, add_solidify=True)

  Create a new mesh object from the current paint mask

  Parameters: | mask_threshold (float in [0, 1], (optional)) – Threshold, Minimum mask value to consider the vertex valid to extract a face from the original mesh add_boundary_loop (boolean, (optional)) – Add Boundary Loop, Add an extra edge loop to better preserve the shape when applying a subdivision surface modifier smooth_iterations (int in [0, inf], (optional)) – Smooth Iterations, Smooth iterations applied to the extracted mesh apply_shrinkwrap (boolean, (optional)) – Project to Sculpt, Project the extracted mesh into the original sculpt add_solidify (boolean, (optional)) – Extract as Solid, Extract the mask as a solid object with a solidify modifier

`bpy.ops.mesh.``paint_mask_slice`(mask_threshold=0.5, fill_holes=True, new_object=True)

  Slices the paint mask from the mesh

  Parameters: | mask_threshold (float in [0, 1], (optional)) – Threshold, Minimum mask value to consider the vertex valid to extract a face from the original mesh fill_holes (boolean, (optional)) – Fill Holes, Fill holes after slicing the mask new_object (boolean, (optional)) – Slice to New Object, Create a new object from the sliced mask

`bpy.ops.mesh.``point_normals`(mode='COORDINATES', invert=False, align=False, target_location=(0.0, 0.0, 0.0), spherize=False, spherize_strength=0.1)

  Point selected custom normals to specified Target

  Parameters: | mode (enum in ['COORDINATES', 'MOUSE'], (optional)) – Mode, How to define coordinates to point custom normals to `COORDINATES` Coordinates, Use static coordinates (defined by various means). `MOUSE` Mouse, Follow mouse cursor. invert (boolean, (optional)) – Invert, Invert affected normals align (boolean, (optional)) – Align, Make all affected normals parallel target_location (float array of 3 items in [-inf, inf], (optional)) – Target, Target location to which normals will point spherize (boolean, (optional)) – Spherize, Interpolate between original and new normals spherize_strength (float in [0, 1], (optional)) – Spherize Strength, Ratio of spherized normal to original normal

`bpy.ops.mesh.``poke`(offset=0.0, use_relative_offset=False, center_mode='MEDIAN_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 ['MEDIAN_WEIGHTED', 'MEDIAN', 'BOUNDS'], (optional)) – Poke Center, Poke Face Center Calculation `MEDIAN_WEIGHTED` Weighted Median, Weighted median face center. `MEDIAN` Median, Median face center. `BOUNDS` Bounds, Face bounds center.

`bpy.ops.mesh.``polybuild_delete_at_cursor`(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

`bpy.ops.mesh.``polybuild_dissolve_at_cursor`()

  Undocumented contribute <https://developer.blender.org/T51061>

`bpy.ops.mesh.``polybuild_extrude_at_cursor_move`(MESH_OT_polybuild_transform_at_cursor=None, MESH_OT_extrude_edges_indiv=None, TRANSFORM_OT_translate=None)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | MESH_OT_polybuild_transform_at_cursor (`MESH_OT_polybuild_transform_at_cursor`, (optional)) – Poly Build Transform at Cursor 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)) – Move, Move selected items

`bpy.ops.mesh.``polybuild_face_at_cursor`(create_quads=True, mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | create_quads (boolean, (optional)) – Create quads, Automatically split edges in triangles to maintain quad topology mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

`bpy.ops.mesh.``polybuild_face_at_cursor_move`(MESH_OT_polybuild_face_at_cursor=None, TRANSFORM_OT_translate=None)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | MESH_OT_polybuild_face_at_cursor (`MESH_OT_polybuild_face_at_cursor`, (optional)) – Poly Build Face at Cursor TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.mesh.``polybuild_split_at_cursor`(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

`bpy.ops.mesh.``polybuild_split_at_cursor_move`(MESH_OT_polybuild_split_at_cursor=None, TRANSFORM_OT_translate=None)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | MESH_OT_polybuild_split_at_cursor (`MESH_OT_polybuild_split_at_cursor`, (optional)) – Poly Build Split at Cursor TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.mesh.``polybuild_transform_at_cursor`(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

`bpy.ops.mesh.``polybuild_transform_at_cursor_move`(MESH_OT_polybuild_transform_at_cursor=None, TRANSFORM_OT_translate=None)

  Undocumented contribute <https://developer.blender.org/T51061>

  Parameters: | MESH_OT_polybuild_transform_at_cursor (`MESH_OT_polybuild_transform_at_cursor`, (optional)) – Poly Build Transform at Cursor TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.mesh.``primitive_circle_add`(vertices=32, radius=1.0, fill_type='NOTHING', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  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 enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_cone_add`(vertices=32, radius1=1.0, radius2=0.0, depth=2.0, end_fill_type='NGON', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  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 enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_cube_add`(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct a cube mesh

  Parameters: | size (float in [0, inf], (optional)) – Size calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_cube_add_gizmo`(calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), matrix=((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)))

  Construct a cube mesh

  Parameters: | calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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 matrix (float multi-dimensional array of 4 * 4 items in [-inf, inf], (optional)) – Matrix

`bpy.ops.mesh.``primitive_cylinder_add`(vertices=32, radius=1.0, depth=2.0, end_fill_type='NGON', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  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 enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_grid_add`(x_subdivisions=10, y_subdivisions=10, size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct a grid mesh

  Parameters: | x_subdivisions (int in [2, 10000000], (optional)) – X Subdivisions y_subdivisions (int in [2, 10000000], (optional)) – Y Subdivisions size (float in [0, inf], (optional)) – Size calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_ico_sphere_add`(subdivisions=2, radius=1.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct an Icosphere mesh

  Parameters: | subdivisions (int in [1, 10], (optional)) – Subdivisions radius (float in [0, inf], (optional)) – Radius calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_monkey_add`(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct a Suzanne mesh

  Parameters: | size (float in [0, inf], (optional)) – Size calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_plane_add`(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct a filled planar mesh with 4 vertices

  Parameters: | size (float in [0, inf], (optional)) – Size calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`bpy.ops.mesh.``primitive_torus_add`(align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), 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=True)

  Construct a torus mesh

  Parameters: | align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new object. location (float array of 3 items in [-inf, inf], (optional)) – Location rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation 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:249

`bpy.ops.mesh.``primitive_uv_sphere_add`(segments=32, ring_count=16, radius=1.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0))

  Construct a UV sphere mesh

  Parameters: | segments (int in [3, 100000], (optional)) – Segments ring_count (int in [3, 100000], (optional)) – Rings radius (float in [0, inf], (optional)) – Radius calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode when adding this object align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) – Align, The alignment of the new object `WORLD` World, Align the new object to the world. `VIEW` View, Align the new object to the view. `CURSOR` 3D Cursor, Use the 3D cursor orientation for the new 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

`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)

  Merge vertices based on their proximity

  Parameters: | threshold (float in [1e-06, 50], (optional)) – Merge Distance, Maximum 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, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False, use_fill=False)

  Disconnect vertex or edges from connected geometry

  Parameters: | mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) 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, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)

  Extend vertices along the edge closest to the cursor

  Parameters: | mirror (boolean, (optional)) – Mirror Editing use_proportional_edit (boolean, (optional)) – Proportional Editing proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) – Proportional 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 use_proportional_connected (boolean, (optional)) – Connected use_proportional_projected (boolean, (optional)) – Projected (2D) 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)) – Move, 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)) – Move, 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`(orientation='LOCAL', sign='POS', axis='X', threshold=0.0001)

  Select all data in the mesh on a single axis

  Parameters: | orientation (enum in ['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR'], (optional)) – Axis Mode, Axis orientation `GLOBAL` Global, Align the transformation axes to world space. `LOCAL` Local, Align the transformation axes to the selected objects’ local space. `NORMAL` Normal, Align the transformation axes to average normal of selected elements (bone Y axis for pose mode). `GIMBAL` Gimbal, Align each axis to the Euler rotation axis as used for input. `VIEW` View, Align the transformation axes to the window. `CURSOR` Cursor, Align the transformation axes to the 3D cursor. sign (enum in ['POS', 'NEG', 'ALIGN'], (optional)) – Axis Sign, Side to select axis (enum in ['X', 'Y', 'Z'], (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 `VERT` Vertex, Vertex selection mode. `EDGE` Edge, Edge selection mode. `FACE` Face, Face selection mode. 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:215

`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`(skip=1, nth=1, offset=0)

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

  Parameters: | skip (int in [1, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence 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:240

`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', 'FREESTYLE_EDGE', 'MATERIAL', 'AREA', 'SIDES', 'PERIMETER', 'NORMAL', 'COPLANAR', 'SMOOTH', 'FACE_MAP', 'FREESTYLE_FACE'], (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`(keep_sharp=False)

  Set the custom normals from the selected faces ones

  Parameters: | keep_sharp (boolean, (optional)) – Keep Sharp Edges, Do not set sharp edges to face

`bpy.ops.mesh.``shape_propagate_to_all`()

  Apply selected vertex locations to all other shape keys

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

  Select shortest path between two selections

  Parameters: | edge_mode (enum in ['SELECT', 'SEAM', 'SHARP', 'CREASE', 'BEVEL', 'FREESTYLE'], (optional)) – Edge Tag, The edge flag to tag when selecting the shortest path 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 skip (int in [0, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

`bpy.ops.mesh.``shortest_path_select`(edge_mode='SELECT', use_face_step=False, use_topology_distance=False, use_fill=False, skip=0, nth=1, offset=0)

  Selected shortest path between two vertices/edges/faces

  Parameters: | edge_mode (enum in ['SELECT', 'SEAM', 'SHARP', 'CREASE', 'BEVEL', 'FREESTYLE'], (optional)) – Edge Tag, The edge flag to tag when selecting the shortest path 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 skip (int in [0, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

`bpy.ops.mesh.``smoothen_normals`(factor=0.5)

  Smoothen custom normals based on adjacent vertex normals

  Parameters: | factor (float in [0, 1], (optional)) – Factor, Specifies weight of smooth vs original normal

`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, use_auto_merge=True, use_normal_flip=False, 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)) – Use Duplicates angle (float in [-inf, inf], (optional)) – Angle, Rotation for each step use_auto_merge (boolean, (optional)) – Auto Merge, Merge first/last when the angle is a full revolution use_normal_flip (boolean, (optional)) – Flip Normals 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.``split_normals`()

  Split custom normals of selected vertices

`bpy.ops.mesh.``subdivide`(number_cuts=1, smoothness=0.0, ngon=True, 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 ngon (boolean, (optional)) – Create N-Gons, When disabled, newly created faces are limited to 3-4 sided faces 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')

  Subdivide perpendicular edges to the selected edge ring

  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.0, repeat=1, xaxis=True, yaxis=True, zaxis=True, wait_for_input=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 wait_for_input (boolean, (optional)) – Wait for Input

`bpy.ops.mesh.``vertices_smooth_laplacian`(repeat=1, lambda_factor=1.0, 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