PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for KDTree Utilities (mathutils.kdtree), preserving all code examples.

assistant: # KDTree Utilities (mathutils.kdtree)

Generic 3-dimensional kd-tree to perform spatial searches.

```
import mathutils

# Create a KD-tree from a mesh.
from bpy import context
obj = context.object

mesh = obj.data
size = len(mesh.vertices)
kd = mathutils.kdtree.KDTree(size)

for i, v in enumerate(mesh.vertices):
    kd.insert(v.co, i)

kd.balance()

# Find the closest point to the center.
co_find = (0.0, 0.0, 0.0)
co, index, dist = kd.find(co_find)
print("Close to center:", co, index, dist)

# 3D cursor relative to the object data.
co_find = obj.matrix_world.inverted() @ context.scene.cursor.location

# Find the closest 10 points to the 3D cursor.
print("Close 10 points")
for (co, index, dist) in kd.find_n(co_find, 10):
    print("    ", co, index, dist)

# Find points within a radius of the 3D cursor.
print("Close points within 0.5 distance")
for (co, index, dist) in kd.find_range(co_find, 0.5):
    print("    ", co, index, dist)
```

*class* mathutils.kdtree.KDTree
:   KdTree(size) -> new kd-tree initialized to hold `size` items.

    > arg size:
    > :   Number of items.
    >
    > type size:
    > :   int

    balance()
    :   Balance the tree.

    find(*co*, *\**, *filter=None*)
    :   Find nearest point to `co`.

        Parameters:
        :   - **co** (*Sequence**[**float**]*) – 3D coordinates.
            - **filter** (*Callable**[**[**int**]**,* *bool**]*) – function which takes an index and returns True for indices to include in the search.

        Returns:
        :   Returns (position, index, distance).

        Return type:
        :   tuple[`Vector`, int, float]

    find_n(*co*, *n*)
    :   Find nearest `n` points to `co`.

        Parameters:
        :   - **co** (*Sequence**[**float**]*) – 3D coordinates.
            - **n** (*int*) – Number of points to find.

        Returns:
        :   Returns a list of tuples (position, index, distance).

        Return type:
        :   list[tuple[`Vector`, int, float]]

    find_range(*co*, *radius*)
    :   Find all points within `radius` of `co`.

        Parameters:
        :   - **co** (*Sequence**[**float**]*) – 3D coordinates.
            - **radius** (*float*) – Distance to search for points.

        Returns:
        :   Returns a list of tuples (position, index, distance).

        Return type:
        :   list[tuple[`Vector`, int, float]]

    insert(*co*, *index*)
    :   Insert a point into the KDTree.

        Parameters:
        :   - **co** (*Sequence**[**float**]*) – Point 3d position.
            - **index** (*int*) – The index of the point.
user: Explain Bpy.Utils.Previews in complete detail according to the official Blender documentation.

assistant: agePreviewCollection.close() bpy.utils.previews.ImagePreviewCollection.load() bpy.utils.previews.ImagePreviewCollection.new()
user: Explain Sorting in complete detail according to the official Blender documentation.

assistant: You can sort the order of your strokes, allowing the lines to stack in the order given.

Sort Key
:   A sort key is used to determine the stacking order of lines.

    Distance from Camera:
    :   Lines closer to the camera lie on top of further lines.

    2D Length:
    :   Longer lines lie on top of shorter lines.

    Projected X/Y:
    :   Sort by the projected X or Y value in the image coordinate system.

Integration Type
:   Use in tandem with the Sort Key to determine the range for sorting.
    Since the distance of a line from the camera may vary over vertices,
    this option computes the sort key for a line from the values computed at
    individual vertices. The value computed for the line is:

    Mean:
    :   The mean of the values obtained for the vertices.

    Min:
    :   The minimum of the values obtained for the vertices.

    Max:
    :   The maximum of the values obtained for the vertices.

    First:
    :   The value obtained for the first vertex.

    Last:
    :   The value obtained for the last vertex.

Sort Order
:   With the given result you can choose to “Reverse” the sort order.
user: How do I use Code Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: Here is an example of threading supported by Blender:

```
import threading
import requests

urls = [
   "http://localhost:8000/file-1.blend",
   "http://localhost:8000/file-2.blend",
   "http://localhost:8000/file-3.blend",
]

def download(url: str) -> None:
   name = threading.current_thread().name
   print("{}: Starting".format(name))
   response = requests.get(url)
   print("{}: Request status code {}".format(name, response.status_code))

threads = [
   threading.Thread(
      name="thread-{}".format(index),
      target=lambda: download(url),
   )
   for index, url in enumerate(urls)
]

print("Starting threads...")
for t in threads:
   t.start()
print("Waiting for threads to finish...")
for t in threads:
   t.join()
print("Threads all done, now Blender can continue")
```

This an example of an **unsupported** case, where a timer which runs many times
a second:

```
from threading import Timer

def my_timer():
      t = Timer(0.1, my_timer)
      t.setDaemon(True)
      t.start()
      print("Running...")

my_timer()
```

Use cases like the one above, which leave the thread running once the script
finishes, may seem to work for a while, but end up causing random crashes or
errors in Blender’s own drawing code.
user: Explain Brush Settings in complete detail according to the official Blender documentation.

assistant: ### General

### Unique

Magnify
:   Pulled geometry tends to lose volume along the stroke.
    With *Magnify* value greater than 0.5 this is prevented.
    More info at [Pinch/Magnify](../../brush/brush_settings.xhtml#bpy-types-brush-crease-pinch-factor)

Rake
:   Rotates geometry along the direction of the stroke.

Deformation
:   Deformation type that is used by the brush.

    Radius Falloff:
    :   Applies the brush falloff to the tip of the brush.

    Elastic:
    :   Modifies the entire mesh using an [Elastic](../../../glossary/index.xhtml#term-Elastic) deformation.
        More info in the [Elastic Deform](elastic_deform.xhtml) brush.
user: What is Bpy.Ops.Grease Pencil and how is it used in Blender Python scripting?

assistant: de for Grease Pencil strokes Parameters : back ( boolean , ( optional ) ) – Return to Previous Mode, Return to previous mode Next Image Operators Previous Graph Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Grease Pencil Operators active_frame_delete() bake_grease_pencil_animation() brush_stroke() caps_set() clean_loose() convert_curve_type() copy() cyclical_set() delete() delete_breakdown() delete_frame() dissolve() duplicate() duplicate_move() erase_box() erase_lasso() extrude() extrude_move() fill() frame_clean_duplicate() frame_duplicate() insert_blank_frame() interpolate() interpolate_sequence() join_selection() layer_active() layer_add() layer_duplicate() layer_duplicate_object() layer_group_add() layer_group_color_tag() layer_group_remove() layer_hide() layer_isolate() layer_lock_all() layer_mask_add() layer_mask_remove() layer_mask_reorder() layer_merge() layer_move() layer_remove() layer_reveal() material_copy_to_object() material_hide() material_isolate() material_lock_all() material_lock_unselected() material_lock_unused() material_reveal() material_select() material_unlock_all() move_to_layer() outline() paintmode_toggle() paste() pen() primitive_arc() primitive_box() primitive_circle() primitive_curve() primitive_line() primitive_polyline() relative_layer_mask_add() remove_fill_guides() reorder() reproject() reset_uvs() sculpt_paint() sculptmode_toggle() select_all() select_alternate() select_ends() select_less() select_linked() select_more() select_random() select_similar() separate() set_active_material() set_corner_type() set_curve_resolution() set_curve_type() set_handle_type() set_material() set_selection_mode() set_start_point() set_uniform_opacity() set_uniform_thickness() snap_cursor_to_selected() snap_to_cursor() snap_to_grid() stroke_material_set() stroke_merge_by_distance() stroke_reset_vertex_color() stroke_simplify() stroke_smooth() stroke_split() stroke_subdivide() stroke_subdivide_smooth() stroke_switch_direction() stroke_trim() texture_gradient() trace_image() vertex_brush_stroke() vertex_color_brightness_contrast() vertex_color_hsv() vertex_color_invert() vertex_color_levels() vertex_color_set() vertex_group_normalize() vertex_group_normalize_all() vertex_group_smooth() vertexmode_toggle() weight_brush_stroke() weight_invert() weight_sample() weight_toggle_direction() weightmode_toggle()
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: Closures define reusable logic that can be injected into another node tree. They are commonly used in procedural systems
where part of the behavior should remain user-defined.

Typical use cases include:

- Defining a custom scattering rule for a terrain generator.
- Describing how to distribute or modify instances procedurally.
- Providing adjustable mappings, field evaluations, or transformation logic.

### Using External Values

Closures can *capture* values from outside their zone. A captured value is stored as part of the closure definition and
remains available even when the closure is evaluated in a different context.

Captured values make it possible to preserve external parameters—such as scale, density, or color—without creating
explicit input sockets. This makes closures cleaner and easier to reuse in different node trees.

[image reference removed]

Capturing an external input value inside a closure.

### Example

1. In a terrain generator node group, replace the tree distribution logic with an
   [Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, create a *Closure Zone* and connect it to that input.
4. Inside the closure zone, define the desired tree placement logic.

When the generator evaluates the closure, the custom distribution defined in the zone is executed instead of the
default behavior.

[image reference removed]

A *Closure Zone* defining a custom distribution pattern for tree scattering.
user: What is Geometry Input Node and how is it used in Blender Python scripting?

assistant: # Geometry Input Node

[image reference removed]

The *Geometry Input* node provides geometry from an external object, collection,
or input connection to be used inside a node group.
It is useful for referencing other geometry data or injecting custom geometry
into a procedural setup.
user: Explain CryptomatteEntry(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CryptomatteEntry(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.CryptomatteEntry(*bpy_struct*)
:   encoded_hash
    :   Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    name
    :   Type:
        :   string, default “”, (readonly, never None)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.xhtml)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.xhtml).

Snap To
:   The target to use while [Snapping](../controls/snapping.xhtml).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the side of the bounding box has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.

Vertices
:   The number of vertices in the caps.

Cap Fill Type
:   Set how the caps will be filled.

    Triangle Fan:
    :   Fill with triangular faces which share a vertex in the middle.

    N-gon:
    :   Fill each ring with an [N-gon](../../../glossary/index.xhtml#term-N-gon).

    Nothing:
    :   Do not fill. Creates only the outer rings of vertices.
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: [image reference removed]

Curve Stroke panel.

Type
:   Type of curve to use for drawing.

    Poly:
    :   Bézier Curve with straight line segments (auto handles).

    Bézier:
    :   Tolerance
        :   Lower values give a result that is closer to the drawing stroke,
            while higher values give more smoothed results.

        Method
        :   Refit:
            :   Incrementally refits the curve (gives best results).

            Split:
            :   Splits the curve until the tolerance is met (gives a better drawing performance).

        Detect Corners
        :   Detects corners while drawing based on a specified angle;
            Any angles above the specified value are considered corners.
            If a corner is detected, the curve uses non-aligned handles
            for the corner resulting in a more crisp corner.

Taper Start, End
:   Taper factor for the radius of the start and end points along the curve.

Radius Min
:   Minimum radius when the minimum pressure is applied (also the minimum when tapering).

Max
:   Radius to use when the maximum pressure is applied (or when a tablet is not used).

Use Pressure
:   Uses stylus pressure to control the radius of the curve.

Depth
:   Controls where and how the curves are drawn.

    Cursor:
    :   Uses the depth under the cursor to draw curves.

    Surface:
    :   Used to draw on top of other objects.

        Project Onto Selected
        :   Only project the strokes onto selected objects.

        Offset
        :   Distance to offset the curve from the surface.

        Absolute Offset
        :   Applies a fixed offset (does not scale by the curve radius).

        Only First
        :   Only uses the start of the stroke for the depth.

        Plane
        :   The orientation plane to draw on, available when *Only First* is enabled.

            Normal to Surface:
            :   Draws aligned to the surface.

            Tangent to Surface:
            :   Draws perpendicular to the surface.

            View:
            :   Draws aligned to the viewport.
user: Give a detailed overview of Add Constraint (with Targets): syntax, arguments, return values, common patterns.

assistant: Adds a constraint to the active object.
The type of constraint must be chosen from a pop-up menu,
though it can be changed later from the *Add Constraint (with Targets)*
[Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
If there is an other object selected besides the active one,
that object will be the constraint target (if the chosen constraint accepts targets).

When using a bone from another armature as the target for a constraint, the tool
will look inside the non-active armature and use its active bone,
provided that armature is in Pose Mode.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Vertex Painting is a simple way of painting color onto an object, by directly
manipulating the color of vertices, rather than textures, and is fairly straightforward.
Vertex Painting stores the color information as a
[Color Attribute](../../modeling/meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes)
which can be used by different render engines.

Color attribute’s can be managed in the pallette pop-over in the middle of the header.

[image reference removed]

Vertex Painting Mode.

When a vertex is painted, the color of the vertex is modified according to
the settings of the brush. The color of all visible planes and edges attached to
the vertex are then modified with a gradient to the color of the other connected vertices.
Note that the color of occluded faces is not modified.
user: What is Examples and how is it used in Blender Python scripting?

assistant: ### Disjoint / Conjoint / Over

The example below shows how different alpha compositing types affect the blending of multiple layers.
Four image layers are assembled using the *Disjoint*, *Conjoint*, and *Over* methods
to create depth between overlapping elements.

[image reference removed]

Assembling a composite image using Alpha Over.

### Fade In

This example uses a [Time Curve Node](../input/scene/time_curve.xhtml)
to gradually animate the *Factor* input of the *Alpha Over* node from 0 to 1 over 30 frames.
The result is a smooth fade-in of text over a background image.

[image reference removed]

Animated fade-in effect using Alpha Over.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Density
:   The value for the new grid at each voxel.

Background
:   The value of the grid outside the *Min*..\*Max\* grid bounds.
    Voxels with a density equal to the background are pruned, which can lead to more memory-efficient volumes.

Min
:   Location of the left-most grid point and lower bound of the voxel volume.

Max
:   Location of the right-most grid point and upper bound of the voxel volume.

Resolution X,Y,Z
:   The number of grid points on each axis.
    The grid contains one less full voxel on each axis than there are grid points.
    For example a *Volume Cube* with resolution 10 has 9 voxels between the left and right grid points.
user: Show practical ways to work with Edge Detection in a Blender add-on or script – include code.

assistant: Crease Angle
:   If two adjacent faces form an angle less than the defined *Crease Angle*,
    the edge between them will be rendered when using *Crease* edge type selection in a line set.
    The value also affects *Silhouette* edge type selection.

Culling
:   Ignore the edges that are out of view.
    (Saves some processing time and memory, but may reduce the quality of the result in some cases.)

Face Smoothness
:   Takes *Smooth Shading* into account for edges calculation.

Sphere Radius
:   Affects the calculation of curvatures for *Ridge*, *Valley*
    and *Suggestive Contour* edge type selection in a line set.
    The curvature at each vertex is computed by averaging the shape
    of the surface within the specified radius.
    Increasing the value reduces noise and detail.

Kr Derivative Epsilon
:   Controls the threshold on the minimum rate of change of curvature used to filter the output
    of the *Suggestive Contour* edge type selection. Increasing the value reduces the amount of
    rendered lines, starting from smoother areas of the object (further information in
    [this PDF](https://archive.blender.org/wiki/2015/index.php/File:Manual-2.6-Render-Freestyle-PrincetownLinestyle.pdf)).
user: Provide the full official documentation entry for Transform, preserving all code examples.

assistant: Filter
:   The technique used to estimate the values of pixels at non-integer coordinates within the image.

    Auto:
    :   Automatically choose filter based on scaling factor.

        - No scale, no rotation, integer positions: *Nearest*
        - Scaling up by more than 2x: *Cubic Mitchell*
        - Scaling down by more than 2x: *Box*
        - Otherwise: Bilinear

    Nearest:
    :   No interpolation; uses nearest neighboring pixel (fastest).

    Bilinear:
    :   Interpolate between 2×2 samples.

    Cubic Mitchell:
    :   Cubic Mitchell filter on 4×4 samples.

    Cubic B-Spline:
    :   Cubic B-Spline filter (blurry but no ringing) on 4×4 samples.

    Box:
    :   Averages source image samples that fall under destination pixel.

Position X, Y
:   Used to move the frames along the X and Y axis.

Scale X, Y
:   Scale the image on the X and Y axis.

Rotation
:   Rotates the input two-dimensionally along the Z axis.

Mirror
:   Mirrors the image along the X axis (left to right) or the Y axis (top to bottom).
user: Describe Converting Particle Systems from the Blender manual or Python API, including usage steps and snippets.

assistant: Make Instances Real
:   Creates a new object of each instanced [object](../../../physics/particles/emitter/render.html#particle-object) or [collection](../../../physics/particles/emitter/render.html#particle-collection).
    See [Make Instances Real](../../../scene_layout/object/editing/apply.html#bpy-ops-object-duplicates-make-real) for more information.

Convert to Mesh
:   Converts [path](../../../physics/particles/emitter/render.html#particle-path) particles to mesh objects.
    See [Convert](../../../scene_layout/object/editing/convert.html#bpy-ops-object-convert) for more information.
user: Provide the full official documentation entry for Source, preserving all code examples.

assistant: Emit From
:   Defines how and where the particles are emitted,
    giving precise control over their distribution.

    Vertices
    :   Emits particles from the vertices of a mesh.

    Faces
    :   Emits particles from the surface of a mesh’s faces.

    Volume
    :   Emits particles from the volume of an enclosed mesh.

Use Modifier Stack
:   Take any [Modifiers](../../../modeling/modifiers/introduction.xhtml) above the Particle Modifier
    in the [modifier stack](../../../modeling/modifiers/introduction.xhtml#modifier-stack) into account when emitting particles,
    else it uses the original mesh geometry.

Distribution
:   These settings control how the emissions of particles are distributed
    throughout the emission locations when emitting from either *Faces* or *Volume*.

    Jittered
    :   Particles are placed at jittered intervals on the emitter elements.

        Particles/Face
        :   Number of emissions per face (0 = automatic).

        Jittering Amount
        :   Amount of jitter applied to the sampling.

    Random
    :   Particles are emitted from random locations in the emitter’s elements.

    Grid
    :   Particles are set in a 3D grid and particles near/in the elements are kept.

        Invert Grid
        :   Invert what is considered the object and what is not.

        Hexagonal
        :   Uses a hexagonal-shaped grid instead of a rectangular one.

        Resolution
        :   Resolution of the grid.

        Random
        :   Add a random offset to grid locations.

Random Order
:   The emitter element indices are gone through
    in a random order instead of linearly (one after the other).

    Not available for *Grid* distribution.

Even Distribution
:   Particle distribution is made even based on surface area of the elements,
    i.e. small elements emit less particles than large elements, so that the particle density is even.
user: Describe Set Grease Pencil Depth Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Set Grease Pencil Depth Node

[image reference removed]

The *Set Grease Pencil Depth* node sets the Grease Pencil
[depth order](../../../../grease_pencil/properties/strokes.xhtml#bpy-types-greasepencil-stroke-depth-order) to use.
user: How do I use Default Workspaces in Blender? Include parameters, examples, warnings and best practices.

assistant: Blender’s default startup shows the “Layout” workspace in the main area.
This workspace is a general workspace to preview your scene
and contains the following Editors:

- [3D Viewport](../../editors/3dview/introduction.xhtml) on top left.
- [Outliner](../../editors/outliner/introduction.xhtml) on top right.
- [Properties](../../editors/properties_editor.xhtml) on bottom right.
- [Dopesheet](../../editors/dope_sheet/index.xhtml) on bottom left.

[image reference removed]

Blender’s ‘Layout’ Workspace with four editors.

3D Viewport (yellow), Outliner (green), Properties (blue) and Timeline (red).

Blender also has several other workspaces added by default:

Modeling:
:   For modification of geometry by modeling tools.

Sculpting:
:   For modification of meshes by sculpting tools.

UV Editing:
:   For mapping of image texture coordinates to 3D surfaces.

Texture Paint:
:   For coloring image textures in the 3D Viewport.

Shading:
:   For specifying material properties for rendering.

Animation:
:   For making properties of objects dependent on time.

Rendering:
:   For viewing and analyzing rendering results.

Compositing:
:   For combining and post-processing of images and rendering information.

Geometry Nodes:
:   For procedural modeling using [Geometry Nodes](../../modeling/geometry_nodes/index.xhtml).

Scripting:
:   For interacting with Blender’s Python API and writing scripts.

### Additional Workspaces

Blender has a couple additional Workspaces to choose from when adding a new Workspace:

2D Animation

2D Animation:
:   General workspace to work with Grease Pencil.

2D Full Canvas:
:   Similar to “2D Animation” but contains a larger canvas.

VFX

Masking:
:   For creating 2D masks for compositing or video editing.

Motion Tracking:
:   For calculating camera motion and stabilizing video footage.

Video Editing

Video Editing:
:   For sequencing together media into one video.
user: Explain SequencerCompositorModifierData(StripModifier) in complete detail according to the official Blender documentation.

assistant: # SequencerCompositorModifierData(StripModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`StripModifier`](bpy.types.StripModifier.html#bpy.types.StripModifier "bpy.types.StripModifier")

*class* bpy.types.SequencerCompositorModifierData(*StripModifier*)
:   Compositor Modifier

    node_group
    :   Node group that controls what this modifier does

        Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

    open_mask_input_panel
    :   Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of PropertyGroupItem(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # PropertyGroupItem(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.PropertyGroupItem(*bpy_struct*)
:   Property that stores arbitrary, user defined properties

    bool
    :   Type:
        :   boolean, default False

    bool_array
    :   Type:
        :   boolean array of 1 items, default (False,)

    collection
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`PropertyGroup`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup "bpy.types.PropertyGroup"), (readonly)

    double
    :   Type:
        :   float in [-inf, inf], default 0.0

    double_array
    :   Type:
        :   float array of 1 items in [-inf, inf], default (0.0)

    enum
    :   Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    float
    :   Type:
        :   float in [-inf, inf], default 0.0

    float_array
    :   Type:
        :   float array of 1 items in [-inf, inf], default (0.0)

    group
    :   Type:
        :   [`PropertyGroup`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup "bpy.types.PropertyGroup"), (readonly)

    id
    :   Type:
        :   [`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")

    idp_array
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`PropertyGroup`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup "bpy.types.PropertyGroup"), (readonly)

    int
    :   Type:
        :   int in [-inf, inf], default 0

    int_array
    :   Type:
        :   int array of 1 items in [-inf, inf], default (0,)

    string
    :   Type:
        :   [string](#bpy.types.PropertyGroupItem.string "bpy.types.PropertyGroupItem.string"), default “”, (never None)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for In Object Mode, preserving all code examples.

assistant: In Object Mode, the Median Point is the averaged-out position of the
[origins](../../../../scene_layout/object/origin.html) of the selected objects.
The shape and size of the objects is not taken into account.

Origins can be chosen freely and can even lie outside their object’s
geometry, so that the Median Point is not always what you might expect.

[image reference removed]

Median points in Object Mode.
user: What is Installing Blender and how is it used in Blender Python scripting?

assistant: Blender downloads can be extracted to any directory on the system, as
a self contained installation. Multiple Blender versions can
co-exist on the same system, and deployment can be automated using
standard file management tools.

New Blender versions may add, remove or change functionality that
affects the results of production files. For a given project, it is
advisable to use a single LTS version
of Blender. LTS versions receive bug fixes for two years.
user: What is Relax Pose to Breakdown and how is it used in Blender Python scripting?

assistant: Relax pose is somewhat related to the above topic, but it is only useful with keyframed bones.
When you edit such a bone (and hence take it “away” from its “keyed position”),
using this tool will progressively “bring it back” to its “keyed position”,
with smaller and smaller steps as it comes near it.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Limits
:   Angular
    :   X Angle, Y Angle, Z Angle
        :   Enables/disables limit rotation around X, Y or Z axis respectively.

            Lower
            :   Lower limit of rotation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of rotation for X, Y or Z axis respectively.

    Linear
    :   X Axis, Y Axis, Z Axis
        :   Enables/disables limit translation on X, Y or Z axis respectively.

            Lower
            :   Lower limit of translation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of translation for X, Y or Z axis respectively.
user: How do I use CameraSolverConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CameraSolverConstraint(Constraint)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint")

*class* bpy.types.CameraSolverConstraint(*Constraint*)
:   Lock motion to the reconstructed camera movement

    clip
    :   Movie Clip to get tracking data from

        Type:
        :   [`MovieClip`](bpy.types.MovieClip.html#bpy.types.MovieClip "bpy.types.MovieClip")

    use_active_clip
    :   Use active clip defined in scene

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Volume
:   Standard volume geometry input.

Mode
:   Random:
    :   Distribute points randomly inside of the volume. The local point count is implicitly
        defined as a product of the global from the *Density* input and the local voxel value.
        This method creates a distribution that is not stable as the input volume deforms.

    Grid:
    :   Distribute the points in a grid pattern inside of the volume. At each grid point, the voxel
        value is used to determine whether to add a point.

Density Random
:   Number of points to sample per unit volume.

Seed Random
:   Seed used by the random number generator to generate random points

Spacing Grid
:   Spacing between grid points.

Threshold Grid
:   Minimum value of a volume cell to contain a grid point.
user: Show practical ways to work with GreasePencilLatticeModifier(Modifier) in a Blender add-on or script – include code.

assistant: # GreasePencilLatticeModifier(Modifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Modifier`](bpy.types.Modifier.html#bpy.types.Modifier "bpy.types.Modifier")

*class* bpy.types.GreasePencilLatticeModifier(*Modifier*)
:   Deform strokes using a lattice object

    invert_layer_filter
    :   Invert layer filter

        Type:
        :   boolean, default False

    invert_layer_pass_filter
    :   Invert layer pass filter

        Type:
        :   boolean, default False

    invert_material_filter
    :   Invert material filter

        Type:
        :   boolean, default False

    invert_material_pass_filter
    :   Invert material pass filter

        Type:
        :   boolean, default False

    invert_vertex_group
    :   Invert vertex group weights

        Type:
        :   boolean, default False

    layer_pass_filter
    :   Layer pass filter

        Type:
        :   int in [0, 100], default 0

    material_filter
    :   Material used for filtering

        Type:
        :   [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

    material_pass_filter
    :   Material pass

        Type:
        :   int in [0, 100], default 0

    object
    :   Lattice object to deform with

        Type:
        :   [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")

    open_influence_panel
    :   Type:
        :   boolean, default False

    strength
    :   Strength of modifier effect

        Type:
        :   float in [-inf, inf], default 1.0

    tree_node_filter
    :   Layer name

        Type:
        :   string, default “”, (never None)

    use_layer_group_filter
    :   Filter by layer group name

        Type:
        :   boolean, default False

    use_layer_pass_filter
    :   Use layer pass filter

        Type:
        :   boolean, default False

    use_material_pass_filter
    :   Use material pass filter

        Type:
        :   boolean, default False

    vertex_group_name
    :   Vertex group name for modulating the deform

        Type:
        :   string, default “”, (never None)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Custom-Data Layer Types from the Blender manual or Python API, including usage steps and snippets.

assistant: *class* bmesh.types.BMLoopUV
:   pin_uv
    :   UV pin state.

        Type:
        :   bool

    uv
    :   Loops UV (as a 2D Vector).

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

*class* bmesh.types.BMDeformVert
:   clear()
    :   Clears all weights.

    get(*key*, *default=None*)
    :   Returns the deform weight matching the key or default
        when not found (matches Python’s dictionary function of the same name).

        Parameters:
        :   - **key** (*int*) – The key associated with deform weight.
            - **default** (*Any*) – Optional argument for the value to return if
              *key* is not found.

    items()
    :   Return (group, weight) pairs for this vertex
        (matching Python’s dict.items() functionality).

        Returns:
        :   (key, value) pairs for each deform weight of this vertex.

        Return type:
        :   list[tuple[int, float]]

    keys()
    :   Return the group indices used by this vertex
        (matching Python’s dict.keys() functionality).

        Returns:
        :   the deform group this vertex uses

        Return type:
        :   list[int]

    values()
    :   Return the weights of the deform vertex
        (matching Python’s dict.values() functionality).

        Returns:
        :   The weights that influence this vertex

        Return type:
        :   list[float]
user: Provide the full official documentation entry for Bpy.Ops.Render, preserving all code examples.

assistant:  , ( optional ) ) – Use Sequencer Scene, Render the sequencer scene instead of the active scene layer ( string , ( optional , never None ) ) – Render Layer, Single render layer to re-render (used only when animation is disabled) scene ( string , ( optional , never None ) ) – Scene, Scene to render, current scene if not specified frame_start ( int in [ -inf , inf ] , ( optional ) ) – Start Frame, Frame to start rendering animation at. If not specified, the scene start frame will be assumed. This should only be specified if doing an animation render frame_end ( int in [ -inf , inf ] , ( optional ) ) – End Frame, Frame to end rendering animation at. If not specified, the scene end frame will be assumed. This should only be specified if doing an animation render bpy.ops.render. shutter_curve_preset ( * , shape = 'SMOOTH' ) ¶ Set shutter curve Parameters : shape (enum in [ 'SHARP' , 'SMOOTH' , 'MAX' , 'LINE' , 'ROUND' , 'ROOT' ], (optional)) – Mode bpy.ops.render. view_cancel ( ) ¶ Cancel show render view bpy.ops.render. view_show ( ) ¶ Toggle show render view Next Rigidbody Operators Previous Ptcache Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Render Operators color_management_white_balance_preset_add() cycles_integrator_preset_add() cycles_performance_preset_add() cycles_sampling_preset_add() cycles_viewport_sampling_preset_add() eevee_raytracing_preset_add() opengl() play_rendered_anim() preset_add() render() shutter_curve_preset() view_cancel() view_show()
user: Describe LightProbeSphere(LightProbe) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LightProbeSphere(LightProbe)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID"), [`LightProbe`](bpy.types.LightProbe.html#bpy.types.LightProbe "bpy.types.LightProbe")

*class* bpy.types.LightProbeSphere(*LightProbe*)
:   Light probe that captures precise lighting from all directions at a single point in space

    clip_end
    :   Probe clip end, beyond which objects will not appear in reflections

        Type:
        :   float in [1e-06, inf], default 20.0

    falloff
    :   Control how fast the probe influence decreases

        Type:
        :   float in [0, 1], default 0.2

    influence_type
    :   Type of influence volume

        Type:
        :   enum in [`'ELIPSOID'`, `'BOX'`], default `'ELIPSOID'`

    parallax_distance
    :   Lowest corner of the parallax bounding box

        Type:
        :   float in [0, inf], default 2.5

    parallax_type
    :   Type of parallax volume

        Type:
        :   enum in [`'ELIPSOID'`, `'BOX'`], default `'ELIPSOID'`

    show_parallax
    :   Show the parallax correction volume in the 3D view

        Type:
        :   boolean, default False

    use_custom_parallax
    :   Enable custom settings for the parallax correction volume

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Blend from Shape: syntax, arguments, return values, common patterns.

assistant: # Blend from Shape

The *Blend from Shape* operator blends the current mesh towards the vertex positions
stored in a [Shape Key](../../../../animation/shape_keys/index.xhtml).
This allows you to reuse existing shape keys to partially or fully reshape geometry in *Edit Mode*.

This is useful for:

- Correcting or refining geometry by borrowing deformations from a shape key.
- Copying specific shape features into a mesh while editing.
- Mixing shapes interactively without leaving Edit Mode.
user: How do I use Interpolate Sequence in Blender? Include parameters, examples, warnings and best practices.

assistant: Interpolate strokes between the previous and next keyframe by adding *multiple* keyframes.
A breakdown keyframe will be added on every frame between the previous and next keyframe.

Step
:   Number of frames between generated interpolated frames.

Layer
:   Layers included in the interpolation.

Exclude Break Downs
:   Exclude existing Breakdowns keyframes as interpolation extremes.

Flip Mode
:   Invert destination stroke to match start and end with source stroke.

Smooth
:   Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise.

Iterations
:   Number of times to smooth newly created strokes.

Type
:   Interpolation method to use the next time *Interpolate Sequence* is run.
user: Describe USERPREF_UL_asset_libraries(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # USERPREF_UL_asset_libraries(UIList)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`UIList`](bpy.types.UIList.html#bpy.types.UIList "bpy.types.UIList")

*class* bpy.types.USERPREF_UL_asset_libraries(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Enabling Add-on and how is it used in Blender Python scripting?

assistant: 1. Open Blender and go to [Add-ons](../../../editors/preferences/addons.html) section of the [Preferences](../../../editors/preferences/index.html).
2. Search “Rigify” and check the *Enable Add-on* checkbox.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

Dynamic paint is a modifier and physics system that can turn objects into paint canvases
and brushes, creating Color Attributes, image sequences, or displacement.
This makes many effects possible like, for example footsteps in the snow,
raindrops that make the ground wet, paint that sticks to walls, or objects that gradually freeze.