# Gpencil Operators

`bpy.ops.gpencil.``active_frame_delete`()

  Delete the active frame for the active Grease Pencil Layer

`bpy.ops.gpencil.``active_frames_delete_all`()

  Delete the active frame(s) of all editable Grease Pencil layers

`bpy.ops.gpencil.``annotate`(mode='DRAW', stroke=None, wait_for_input=True)

  Make annotations on the active data

  Parameters: | mode (enum in ['DRAW', 'DRAW_STRAIGHT', 'DRAW_POLY', 'ERASER'], (optional)) – Mode, Way to interpret mouse movements `DRAW` Draw Freehand, Draw freehand stroke(s). `DRAW_STRAIGHT` Draw Straight Lines, Draw straight line segment(s). `DRAW_POLY` Draw Poly Line, Click to place endpoints of straight line segments (connected). `ERASER` Eraser, Erase Annotation strokes. stroke (`bpy_prop_collection` of `OperatorStrokeElement`, (optional)) – Stroke wait_for_input (boolean, (optional)) – Wait for Input, Wait for first click instead of painting immediately

`bpy.ops.gpencil.``annotation_active_frame_delete`()

  Delete the active frame for the active Annotation Layer

`bpy.ops.gpencil.``annotation_add`()

  Add new Annotation data-block

`bpy.ops.gpencil.``blank_frame_add`(all_layers=False)

  Insert a blank frame on the current frame (all subsequently existing frames, if any, are shifted right by one frame)

  Parameters: | all_layers (boolean, (optional)) – All Layers, Create blank frame in all layers, not only active

`bpy.ops.gpencil.``brush_presets_create`()

  Create a set of predefined Grease Pencil drawing brushes

`bpy.ops.gpencil.``color_hide`(unselected=False)

  Hide selected/unselected Grease Pencil colors

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

`bpy.ops.gpencil.``color_isolate`(affect_visibility=False)

  Toggle whether the active color is the only one that is editable and/or visible

  Parameters: | affect_visibility (boolean, (optional)) – Affect Visibility, In addition to toggling the editability, also affect the visibility

`bpy.ops.gpencil.``color_lock_all`()

  Lock all Grease Pencil colors to prevent them from being accidentally modified

`bpy.ops.gpencil.``color_reveal`()

  Unhide all hidden Grease Pencil colors

`bpy.ops.gpencil.``color_select`(deselect=False)

  Select all Grease Pencil strokes using current color

  Parameters: | deselect (boolean, (optional)) – Deselect, Unselect strokes

`bpy.ops.gpencil.``color_unlock_all`()

  Unlock all Grease Pencil colors so that they can be edited

`bpy.ops.gpencil.``convert`(type='PATH', use_normalize_weights=True, radius_multiplier=1.0, use_link_strokes=False, timing_mode='FULL', frame_range=100, start_frame=1, use_realtime=False, end_frame=250, gap_duration=0.0, gap_randomness=0.0, seed=0, use_timing_data=False)

  Convert the active Grease Pencil layer to a new Curve Object

  Parameters: | type (enum in ['PATH', 'CURVE', 'POLY'], (optional)) – Type, Which type of curve to convert to `PATH` Path, Animation path. `CURVE` Bezier Curve, Smooth Bezier curve. `POLY` Polygon Curve, Bezier curve with straight-line segments (vector handles). use_normalize_weights (boolean, (optional)) – Normalize Weight, Normalize weight (set from stroke width) radius_multiplier (float in [0, 1000], (optional)) – Radius Fac, Multiplier for the points’ radii (set from stroke width) use_link_strokes (boolean, (optional)) – Link Strokes, Whether to link strokes with zero-radius sections of curves timing_mode (enum in ['NONE', 'LINEAR', 'FULL', 'CUSTOMGAP'], (optional)) – Timing Mode, How to use timing data stored in strokes `NONE` No Timing, Ignore timing. `LINEAR` Linear, Simple linear timing. `FULL` Original, Use the original timing, gaps included. `CUSTOMGAP` Custom Gaps, Use the original timing, but with custom gap lengths (in frames). frame_range (int in [1, 10000], (optional)) – Frame Range, The duration of evaluation of the path control curve start_frame (int in [1, 100000], (optional)) – Start Frame, The start frame of the path control curve use_realtime (boolean, (optional)) – Realtime, Whether the path control curve reproduces the drawing in realtime, starting from Start Frame end_frame (int in [1, 100000], (optional)) – End Frame, The end frame of the path control curve (if Realtime is not set) gap_duration (float in [0, 10000], (optional)) – Gap Duration, Custom Gap mode: (Average) length of gaps, in frames (Note: Realtime value, will be scaled if Realtime is not set) gap_randomness (float in [0, 10000], (optional)) – Gap Randomness, Custom Gap mode: Number of frames that gap lengths can vary seed (int in [0, 1000], (optional)) – Random Seed, Custom Gap mode: Random generator seed use_timing_data (boolean, (optional)) – Has Valid Timing, Whether the converted Grease Pencil layer has valid timing data (internal use)

`bpy.ops.gpencil.``convert_old_files`(annotation=False)

  Convert 2.7x grease pencil files to 2.80

  Parameters: | annotation (boolean, (optional)) – Annotation, Convert to Annotations

`bpy.ops.gpencil.``copy`()

  Copy selected Grease Pencil points and strokes

`bpy.ops.gpencil.``data_unlink`()

  Unlink active Annotation data-block

`bpy.ops.gpencil.``delete`(type='POINTS')

  Delete selected Grease Pencil strokes, vertices, or frames

  Parameters: | type (enum in ['POINTS', 'STROKES', 'FRAME'], (optional)) – Type, Method used for deleting Grease Pencil data `POINTS` Points, Delete selected points and split strokes into segments. `STROKES` Strokes, Delete selected strokes. `FRAME` Frame, Delete active frame.

`bpy.ops.gpencil.``dissolve`(type='POINTS')

  Delete selected points without splitting strokes

  Parameters: | type (enum in ['POINTS', 'BETWEEN', 'UNSELECT'], (optional)) – Type, Method used for dissolving Stroke points `POINTS` Dissolve, Dissolve selected points. `BETWEEN` Dissolve Between, Dissolve points between selected points. `UNSELECT` Dissolve Unselect, Dissolve all unselected points.

`bpy.ops.gpencil.``draw`(mode='DRAW', stroke=None, wait_for_input=True, disable_straight=False, disable_fill=False, guide_last_angle=0.0)

  Draw a new stroke in the active Grease Pencil Object

  Parameters: | mode (enum in ['DRAW', 'DRAW_STRAIGHT', 'DRAW_POLY', 'ERASER'], (optional)) – Mode, Way to interpret mouse movements `DRAW` Draw Freehand, Draw freehand stroke(s). `DRAW_STRAIGHT` Draw Straight Lines, Draw straight line segment(s). `DRAW_POLY` Draw Poly Line, Click to place endpoints of straight line segments (connected). `ERASER` Eraser, Erase Grease Pencil strokes. stroke (`bpy_prop_collection` of `OperatorStrokeElement`, (optional)) – Stroke wait_for_input (boolean, (optional)) – Wait for Input, Wait for first click instead of painting immediately disable_straight (boolean, (optional)) – No Straight lines, Disable key for straight lines disable_fill (boolean, (optional)) – No Fill Areas, Disable fill to use stroke as fill boundary guide_last_angle (float in [-10000, 10000], (optional)) – Angle, Speed guide angle

`bpy.ops.gpencil.``duplicate`()

  Duplicate the selected Grease Pencil strokes

`bpy.ops.gpencil.``duplicate_move`(GPENCIL_OT_duplicate=None, TRANSFORM_OT_translate=None)

  Make copies of the selected Grease Pencil strokes and move them

  Parameters: | GPENCIL_OT_duplicate (`GPENCIL_OT_duplicate`, (optional)) – Duplicate Strokes, Duplicate the selected Grease Pencil strokes TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.gpencil.``editmode_toggle`(back=False)

  Enter/Exit edit mode for Grease Pencil strokes

  Parameters: | back (boolean, (optional)) – Return to Previous Mode, Return to previous mode

`bpy.ops.gpencil.``extrude`()

  Extrude the selected Grease Pencil points

`bpy.ops.gpencil.``extrude_move`(GPENCIL_OT_extrude=None, TRANSFORM_OT_translate=None)

  Extrude selected points and move them

  Parameters: | GPENCIL_OT_extrude (`GPENCIL_OT_extrude`, (optional)) – Extrude Stroke Points, Extrude the selected Grease Pencil points TRANSFORM_OT_translate (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

`bpy.ops.gpencil.``fill`(on_back=False)

  Fill with color the shape formed by strokes

  Parameters: | on_back (boolean, (optional)) – Draw On Back, Send new stroke to Back

`bpy.ops.gpencil.``frame_clean_fill`(mode='ACTIVE')

  Remove ‘no fill’ boundary strokes

  Parameters: | mode (enum in ['ACTIVE', 'ALL'], (optional)) – Mode `ACTIVE` Active Frame Only, Clean active frame only. `ALL` All Frames, Clean all frames in all layers.

`bpy.ops.gpencil.``frame_clean_loose`(limit=1)

  Remove loose points

  Parameters: | limit (int in [1, inf], (optional)) – Limit, Number of points to consider stroke as loose

`bpy.ops.gpencil.``frame_duplicate`(mode='ACTIVE')

  Make a copy of the active Grease Pencil Frame

  Parameters: | mode (enum in ['ACTIVE', 'ALL'], (optional)) – Mode `ACTIVE` Active, Duplicate frame in active layer only. `ALL` All, Duplicate active frames in all layers.

`bpy.ops.gpencil.``generate_weights`(mode='NAME', armature='DEFAULT', ratio=0.1, decay=0.8)

  Generate automatic weights for armatures (requires armature modifier)

  Parameters: | mode (enum in ['NAME', 'AUTO'], (optional)) – Mode armature (enum in ['DEFAULT'], (optional)) – Armature, Armature to use ratio (float in [0, 2], (optional)) – Ratio, Ratio between bone length and influence radius decay (float in [0, 1], (optional)) – Decay, Factor to reduce influence depending of distance to bone axis

`bpy.ops.gpencil.``guide_rotate`(increment=True, angle=0.0)

  Rotate guide angle

  Parameters: | increment (boolean, (optional)) – Increment, Increment angle angle (float in [-10000, 10000], (optional)) – Angle, Guide angle

`bpy.ops.gpencil.``hide`(unselected=False)

  Hide selected/unselected Grease Pencil layers

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

`bpy.ops.gpencil.``interpolate`(shift=0.0)

  Interpolate grease pencil strokes between frames

  Parameters: | shift (float in [-1, 1], (optional)) – Shift, Bias factor for which frame has more influence on the interpolated strokes

`bpy.ops.gpencil.``interpolate_reverse`()

  Remove breakdown frames generated by interpolating between two Grease Pencil frames

`bpy.ops.gpencil.``interpolate_sequence`()

  Generate ‘in-betweens’ to smoothly interpolate between Grease Pencil frames

`bpy.ops.gpencil.``layer_add`()

  Add new layer or note for the active data-block

`bpy.ops.gpencil.``layer_annotation_add`()

  Add new Annotation layer or note for the active data-block

`bpy.ops.gpencil.``layer_annotation_move`(type='UP')

  Move the active Annotation layer up/down in the list

  Parameters: | type (enum in ['UP', 'DOWN'], (optional)) – Type

`bpy.ops.gpencil.``layer_annotation_remove`()

  Remove active Annotation layer

`bpy.ops.gpencil.``layer_change`(layer='DEFAULT')

  Change active Grease Pencil layer

  Parameters: | layer (enum in ['DEFAULT'], (optional)) – Grease Pencil Layer

`bpy.ops.gpencil.``layer_duplicate`()

  Make a copy of the active Grease Pencil layer

`bpy.ops.gpencil.``layer_duplicate_object`(object="", mode='ALL')

  Make a copy of the active Grease Pencil layer to new object

  Parameters: | object (string, (optional, never None)) – Object, Name of the destination object mode (enum in ['ALL', 'ACTIVE'], (optional)) – Mode

`bpy.ops.gpencil.``layer_isolate`(affect_visibility=False)

  Toggle whether the active layer is the only one that can be edited and/or visible

  Parameters: | affect_visibility (boolean, (optional)) – Affect Visibility, In addition to toggling the editability, also affect the visibility

`bpy.ops.gpencil.``layer_merge`()

  Merge the current layer with the layer below

`bpy.ops.gpencil.``layer_move`(type='UP')

  Move the active Grease Pencil layer up/down in the list

  Parameters: | type (enum in ['UP', 'DOWN'], (optional)) – Type

`bpy.ops.gpencil.``layer_remove`()

  Remove active Grease Pencil layer

`bpy.ops.gpencil.``lock_all`()

  Lock all Grease Pencil layers to prevent them from being accidentally modified

`bpy.ops.gpencil.``lock_layer`()

  Lock and hide any color not used in any layer

`bpy.ops.gpencil.``move_to_layer`(layer=0)

  Move selected strokes to another layer

  Parameters: | layer (int in [0, inf], (optional)) – Grease Pencil Layer

`bpy.ops.gpencil.``paintmode_toggle`(back=False)

  Enter/Exit paint mode for Grease Pencil strokes

  Parameters: | back (boolean, (optional)) – Return to Previous Mode, Return to previous mode

`bpy.ops.gpencil.``paste`(type='ACTIVE')

  Paste previously copied strokes to active layer or to original layer

  Parameters: | type (enum in ['ACTIVE', 'LAYER'], (optional)) – Type

`bpy.ops.gpencil.``primitive`(edges=4, type='BOX', wait_for_input=True)

  Create predefined grease pencil stroke shapes

  Parameters: | edges (int in [2, 128], (optional)) – Edges, Number of polygon edges type (enum in ['BOX', 'LINE', 'POLYLINE', 'CIRCLE', 'ARC', 'CURVE'], (optional)) – Type, Type of shape wait_for_input (boolean, (optional)) – Wait for Input

`bpy.ops.gpencil.``reproject`(type='VIEW')

  Reproject the selected strokes from the current viewpoint as if they had been newly drawn (e.g. to fix problems from accidental 3D cursor movement or accidental viewport changes, or for matching deforming geometry)

  Parameters: | type (enum in ['FRONT', 'SIDE', 'TOP', 'VIEW', 'SURFACE', 'CURSOR'], (optional)) – Projection Type `FRONT` Front, Reproject the strokes using the X-Z plane. `SIDE` Side, Reproject the strokes using the Y-Z plane. `TOP` Top, Reproject the strokes using the X-Y plane. `VIEW` View, Reproject the strokes to end up on the same plane, as if drawn from the current viewpoint using ‘Cursor’ Stroke Placement. `SURFACE` Surface, Reproject the strokes on to the scene geometry, as if drawn using ‘Surface’ placement. `CURSOR` Cursor, Reproject the strokes using the orientation of 3D cursor.

`bpy.ops.gpencil.``reveal`(select=True)

  Show all Grease Pencil layers

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

`bpy.ops.gpencil.``sculpt_paint`(stroke=None, wait_for_input=True)

  Apply tweaks to strokes by painting over the strokes

  Parameters: | stroke (`bpy_prop_collection` of `OperatorStrokeElement`, (optional)) – Stroke wait_for_input (boolean, (optional)) – Wait for Input, Enter a mini ‘sculpt-mode’ if enabled, otherwise, exit after drawing a single stroke

`bpy.ops.gpencil.``sculptmode_toggle`(back=False)

  Enter/Exit sculpt mode for Grease Pencil strokes

  Parameters: | back (boolean, (optional)) – Return to Previous Mode, Return to previous mode

`bpy.ops.gpencil.``select`(extend=False, deselect=False, toggle=False, deselect_all=False, entire_strokes=False, location=(0, 0))

  Select Grease Pencil strokes and/or stroke points

  Parameters: | extend (boolean, (optional)) – Extend, Extend selection instead of deselecting everything first deselect (boolean, (optional)) – Deselect, Remove from selection toggle (boolean, (optional)) – Toggle Selection, Toggle the selection deselect_all (boolean, (optional)) – Deselect On Nothing, Deselect all when nothing under the cursor entire_strokes (boolean, (optional)) – Entire Strokes, Select entire strokes instead of just the nearest stroke vertex location (int array of 2 items in [-inf, inf], (optional)) – Location, Mouse location

`bpy.ops.gpencil.``select_all`(action='TOGGLE')

  Change selection of all Grease Pencil strokes currently visible

  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.gpencil.``select_alternate`(unselect_ends=True)

  Select alternative points in same strokes as already selected points

  Parameters: | unselect_ends (boolean, (optional)) – Unselect Ends, Do not select the first and last point of the stroke

`bpy.ops.gpencil.``select_box`(xmin=0, xmax=0, ymin=0, ymax=0, wait_for_input=True, mode='SET')

  Select Grease Pencil strokes within a rectangular region

  Parameters: | xmin (int in [-inf, inf], (optional)) – X Min xmax (int in [-inf, inf], (optional)) – X Max ymin (int in [-inf, inf], (optional)) – Y Min ymax (int in [-inf, inf], (optional)) – Y Max wait_for_input (boolean, (optional)) – Wait for Input mode (enum in ['SET', 'ADD', 'SUB', 'XOR', 'AND'], (optional)) – Mode `SET` Set, Set a new selection. `ADD` Extend, Extend existing selection. `SUB` Subtract, Subtract existing selection. `XOR` Difference, Inverts existing selection. `AND` Intersect, Intersect existing selection.

`bpy.ops.gpencil.``select_circle`(x=0, y=0, radius=25, wait_for_input=True, mode='SET')

  Select Grease Pencil strokes using brush selection

  Parameters: | x (int in [-inf, inf], (optional)) – X y (int in [-inf, inf], (optional)) – Y radius (int in [1, inf], (optional)) – Radius wait_for_input (boolean, (optional)) – Wait for Input mode (enum in ['SET', 'ADD', 'SUB'], (optional)) – Mode `SET` Set, Set a new selection. `ADD` Extend, Extend existing selection. `SUB` Subtract, Subtract existing selection.

`bpy.ops.gpencil.``select_first`(only_selected_strokes=False, extend=False)

  Select first point in Grease Pencil strokes

  Parameters: | only_selected_strokes (boolean, (optional)) – Selected Strokes Only, Only select the first point of strokes that already have points selected extend (boolean, (optional)) – Extend, Extend selection instead of deselecting all other selected points

`bpy.ops.gpencil.``select_grouped`(type='LAYER')

  Select all strokes with similar characteristics

  Parameters: | type (enum in ['LAYER', 'MATERIAL'], (optional)) – Type `LAYER` Layer, Shared layers. `MATERIAL` Material, Shared materials.

`bpy.ops.gpencil.``select_lasso`(mode='SET', path=None)

  Select Grease Pencil strokes using lasso selection

  Parameters: | mode (enum in ['SET', 'ADD', 'SUB', 'XOR', 'AND'], (optional)) – Mode `SET` Set, Set a new selection. `ADD` Extend, Extend existing selection. `SUB` Subtract, Subtract existing selection. `XOR` Difference, Inverts existing selection. `AND` Intersect, Intersect existing selection. path (`bpy_prop_collection` of `OperatorMousePath`, (optional)) – Path

`bpy.ops.gpencil.``select_last`(only_selected_strokes=False, extend=False)

  Select last point in Grease Pencil strokes

  Parameters: | only_selected_strokes (boolean, (optional)) – Selected Strokes Only, Only select the last point of strokes that already have points selected extend (boolean, (optional)) – Extend, Extend selection instead of deselecting all other selected points

`bpy.ops.gpencil.``select_less`()

  Shrink sets of selected Grease Pencil points

`bpy.ops.gpencil.``select_linked`()

  Select all points in same strokes as already selected points

`bpy.ops.gpencil.``select_more`()

  Grow sets of selected Grease Pencil points

`bpy.ops.gpencil.``selection_opacity_toggle`()

  Hide/Unhide selected points for Grease Pencil strokes setting alpha factor

`bpy.ops.gpencil.``selectmode_toggle`(mode=0)

  Set selection mode for Grease Pencil strokes

  Parameters: | mode (int in [0, 2], (optional)) – Select mode, Select mode

`bpy.ops.gpencil.``set_active_material`()

  Set the selected stroke material as the active material

`bpy.ops.gpencil.``snap_cursor_to_selected`()

  Snap cursor to center of selected points

`bpy.ops.gpencil.``snap_to_cursor`(use_offset=True)

  Snap selected points/strokes to the cursor

  Parameters: | use_offset (boolean, (optional)) – With Offset, Offset the entire stroke instead of selected points only

`bpy.ops.gpencil.``snap_to_grid`()

  Snap selected points to the nearest grid points

`bpy.ops.gpencil.``stroke_apply_thickness`()

  Apply the thickness change of the layer to its strokes

`bpy.ops.gpencil.``stroke_arrange`(direction='UP')

  Arrange selected strokes up/down in the drawing order of the active layer

  Parameters: | direction (enum in ['TOP', 'UP', 'DOWN', 'BOTTOM'], (optional)) – Direction

`bpy.ops.gpencil.``stroke_caps_set`(type='TOGGLE')

  Change Stroke caps mode (rounded or flat)

  Parameters: | type (enum in ['TOGGLE', 'START', 'END', 'TOGGLE'], (optional)) – Type `TOGGLE` Both. `START` Start. `END` End. `TOGGLE` Default, Set as default rounded.

`bpy.ops.gpencil.``stroke_change_color`(material="")

  Move selected strokes to active material

  Parameters: | material (string, (optional, never None)) – Material, Name of the material

`bpy.ops.gpencil.``stroke_cutter`(path=None)

  Select section and cut

  Parameters: | path (`bpy_prop_collection` of `OperatorMousePath`, (optional)) – Path

`bpy.ops.gpencil.``stroke_cyclical_set`(type='TOGGLE', geometry=False)

  Close or open the selected stroke adding an edge from last to first point

  Parameters: | type (enum in ['CLOSE', 'OPEN', 'TOGGLE'], (optional)) – Type geometry (boolean, (optional)) – Create Geometry, Create new geometry for closing stroke

`bpy.ops.gpencil.``stroke_flip`()

  Change direction of the points of the selected strokes

`bpy.ops.gpencil.``stroke_join`(type='JOIN', leave_gaps=False)

  Join selected strokes (optionally as new stroke)

  Parameters: | type (enum in ['JOIN', 'JOINCOPY'], (optional)) – Type leave_gaps (boolean, (optional)) – Leave Gaps, Leave gaps between joined strokes instead of linking them

`bpy.ops.gpencil.``stroke_lock_color`()

  Lock any color not used in any selected stroke

`bpy.ops.gpencil.``stroke_merge`(mode='STROKE', back=False, additive=False, cyclic=False, clear_point=False, clear_stroke=False)

  Create a new stroke with the selected stroke points

  Parameters: | mode (enum in ['STROKE', 'POINT'], (optional)) – Mode back (boolean, (optional)) – Draw on Back, Draw new stroke below all previous strokes additive (boolean, (optional)) – Additive Drawing, Add to previous drawing cyclic (boolean, (optional)) – Cyclic, Close new stroke clear_point (boolean, (optional)) – Dissolve Points, Dissolve old selected points clear_stroke (boolean, (optional)) – Delete Strokes, Delete old selected strokes

`bpy.ops.gpencil.``stroke_merge_by_distance`(threshold=0.001, use_unselected=False)

  Merge points by distance

  Parameters: | threshold (float in [0, 100], (optional)) – Threshold use_unselected (boolean, (optional)) – Unselected, Use whole stroke, not only selected points

`bpy.ops.gpencil.``stroke_sample`(length=0.1)

  Sample stroke points to predefined segment length

  Parameters: | length (float in [0, 100], (optional)) – Length

`bpy.ops.gpencil.``stroke_separate`(mode='POINT')

  Separate the selected strokes or layer in a new grease pencil object

  Parameters: | mode (enum in ['POINT', 'STROKE', 'LAYER'], (optional)) – Mode `POINT` Selected Points, Separate the selected points. `STROKE` Selected Strokes, Separate the selected strokes. `LAYER` Active Layer, Separate the strokes of the current layer.

`bpy.ops.gpencil.``stroke_simplify`(factor=0.0)

  Simplify selected stroked reducing number of points

  Parameters: | factor (float in [0, 100], (optional)) – Factor

`bpy.ops.gpencil.``stroke_simplify_fixed`(step=1)

  Simplify selected stroked reducing number of points using fixed algorithm

  Parameters: | step (int in [1, 100], (optional)) – Steps, Number of simplify steps

`bpy.ops.gpencil.``stroke_smooth`(repeat=1, factor=0.5, only_selected=True, smooth_position=True, smooth_thickness=True, smooth_strength=False, smooth_uv=False)

  Smooth selected strokes

  Parameters: | repeat (int in [1, 50], (optional)) – Repeat factor (float in [0, 2], (optional)) – Factor only_selected (boolean, (optional)) – Selected Points, Smooth only selected points in the stroke smooth_position (boolean, (optional)) – Position smooth_thickness (boolean, (optional)) – Thickness smooth_strength (boolean, (optional)) – Strength smooth_uv (boolean, (optional)) – UV

`bpy.ops.gpencil.``stroke_split`()

  Split selected points as new stroke on same frame

`bpy.ops.gpencil.``stroke_subdivide`(number_cuts=1, factor=0.0, repeat=1, only_selected=True, smooth_position=True, smooth_thickness=True, smooth_strength=False, smooth_uv=False)

  Subdivide between continuous selected points of the stroke adding a point half way between them

  Parameters: | number_cuts (int in [1, 10], (optional)) – Number of Cuts factor (float in [0, 2], (optional)) – Smooth repeat (int in [1, 10], (optional)) – Repeat only_selected (boolean, (optional)) – Selected Points, Smooth only selected points in the stroke smooth_position (boolean, (optional)) – Position smooth_thickness (boolean, (optional)) – Thickness smooth_strength (boolean, (optional)) – Strength smooth_uv (boolean, (optional)) – UV

`bpy.ops.gpencil.``stroke_trim`()

  Trim selected stroke to first loop or intersection

`bpy.ops.gpencil.``unlock_all`()

  Unlock all Grease Pencil layers so that they can be edited

`bpy.ops.gpencil.``vertex_group_assign`()

  Assign the selected vertices to the active vertex group

`bpy.ops.gpencil.``vertex_group_deselect`()

  Deselect all selected vertices assigned to the active vertex group

`bpy.ops.gpencil.``vertex_group_invert`()

  Invert weights to the active vertex group

`bpy.ops.gpencil.``vertex_group_normalize`()

  Normalize weights to the active vertex group

`bpy.ops.gpencil.``vertex_group_normalize_all`(lock_active=True)

  Normalize all weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0

  Parameters: | lock_active (boolean, (optional)) – Lock Active, Keep the values of the active group while normalizing others

`bpy.ops.gpencil.``vertex_group_remove_from`()

  Remove the selected vertices from active or all vertex group(s)

`bpy.ops.gpencil.``vertex_group_select`()

  Select all the vertices assigned to the active vertex group

`bpy.ops.gpencil.``vertex_group_smooth`(factor=0.5, repeat=1)

  Smooth weights to the active vertex group

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

`bpy.ops.gpencil.``weightmode_toggle`(back=False)

  Enter/Exit weight paint mode for Grease Pencil strokes

  Parameters: | back (boolean, (optional)) – Return to Previous Mode, Return to previous mode