`ovito.nonpublic`

This page documents selected internal/advanced APIs from the ovito.nonpublic module. These are not part of OVITO’s stable, documented Python interface and are normally left out of the end-user manual; they are included here only for AI agent consumption.

class ovito.nonpublic.ActiveObject

Abstract base class for pipeline-related objects that perform potentially long-running background computations and that can be enabled or disabled, such as Modifier, DataVis, PipelineNode (and thus ModificationNode, FileSource, etc.), ViewportOverlay, and ModifierGroup. It provides a common title, an enabled flag, and a status reporting the outcome of the object’s most recent computation.

property enabled: bool

Controls whether this object is currently active. Setting this to False disables the object, e.g. excluding a Modifier from being applied within its pipeline, without removing it.

Default:: True

property status: PipelineStatus: Reports the outcome of this object’s most recently performed computation.

Attention

In some cases this field is only updated when OVITO is running in GUI mode.

property title: str

An optional, user-defined title for this object, shown in place of its default, type-derived name in the pipeline editor of the OVITO GUI when non-empty.

Default:: ''

class ovito.nonpublic.AnimationKey

Abstract base class for a single keyframe of a KeyframeController, storing a time and a type-specific value at that time (see the concrete subclasses FloatAnimationKey, IntegerAnimationKey, Vector3AnimationKey, PositionAnimationKey, RotationAnimationKey, and ScalingAnimationKey). Between consecutive keys, the owning controller’s value is obtained through interpolation.

property time: int: The animation time at which this key is positioned, given as a zero-based frame number.

class ovito.nonpublic.AnimationSettings

Stores the global animation/playback settings and state associated with a Scene, accessible through the Scene.anim attribute (i.e. ovito.scene.anim). This includes the length of the animation interval (first_frame/last_frame), the position of the time slider (current_frame), and the playback-related parameters used by the interactive viewports and by movie export (frames_per_second, playback_speed, loop_playback, play_every_nth_frame).

See also manual:animation.animation_settings_dialog in the OVITO user manual, which describes the corresponding animation settings dialog in the GUI

property auto_adjust_interval: bool

Controls whether the animation interval (first_frame/last_frame) is automatically adjusted to accommodate all trajectory frames produced by the data pipelines in the Scene. When enabled, loading a new simulation trajectory or importing an additional trajectory automatically extends last_frame to cover its full length.

In other words, if this option is enabled, the animation interval always covers the maximum Pipeline.num_frames of all data pipelines in the current scene. If this option is disabled, the animation interval is not automatically adjusted, and you can set first_frame and last_frame manually to any values you like, even if they are outside the range of the loaded simulation trajectory.

Default:: True

property current_frame: int

The current animation frame. This parameter controls the position of the time slider in OVITO’s main window and determines which animation frame is shown in the viewports. It also affects various other functions that operate on the current animation frame.

Default:: 0

property first_frame: int

The zero-based index of the first animation frame.

Default:: 0

property frames_per_second: float

Controls the playback speed of the animation. This parameter also determines the playback speed of movie files generated by OVITO.

Default:: 10.0

jump_to_animation_end(): Sets current_frame to last_frame, moving the time slider to the end of the animation interval.

jump_to_animation_start(): Sets current_frame to first_frame, moving the time slider to the start of the animation interval.

jump_to_next_frame(): Advances current_frame by one frame, unless it is already at last_frame.

jump_to_previous_frame(): Moves current_frame back by one frame, unless it is already at first_frame.

property last_frame: int

The zero-based index of the last animation frame. You can set this property to change the animation length.

Default:: 0

property loop_playback: bool

Controls whether interactive playback in the viewports restarts from first_frame after reaching last_frame, instead of stopping there.

Default:: True

property play_every_nth_frame: int

Specifies the number of animation frames to advance per step during interactive playback in the viewports. A value of 1 plays every frame; a value of n skips ahead by n frames on each playback step, which can be used to move through long trajectories more quickly at the cost of temporal resolution. This setting has no effect on movie export.

Default:: 1

property playback_speed: int

An integer speed factor controlling the rate of interactive playback in the viewports, using an asymmetric encoding: values greater than 1 play the animation faster than realtime, at playback_speed times the normal rate; values less than -1 play it slower than realtime, at a rate of 1 / abs(playback_speed) times the normal rate. This setting has no effect on movie export, which is governed by frames_per_second instead.

Default:: 1

property prefer_simulation_time_display: bool

Controls whether the timeline in the GUI preferentially displays simulation time or timestep values (if available) instead of zero-based trajectory frame numbers.

Default:: False

class ovito.nonpublic.Controller

Abstract base class for animatable parameter controllers. A Controller manages the time-dependent value of a single animatable quantity – a scalar (float or int), a 3d vector or RGB color, a position, a rotation, a scaling, or a full position/rotation/scaling transformation – and is queried and manipulated through whichever get_*_value/set_*_value method pair matches its type.

Concrete controller implementations differ in how they compute a value for a given time. The most common kind, a KeyframeController, interpolates between a sequence of user-defined AnimationKey instances (see KeyframeController.keys and manual:usage.animation.keyframes in the OVITO user manual), while a PRSTransformationController instead delegates to three separate sub-controllers for position, rotation and scaling. Controllers are attached, for example, to SceneNode instances (transform_ctrl) to animate their position and orientation in the scene.

get_color_value(time: int) → tuple[float, float, float]: Returns this controller’s value, reinterpreted as an RGB color, at the given animation time (a zero-based frame number). Only meaningful if type is Controller.Type.Vector3; equivalent to get_vector3_value().

get_float_value(time: int) → float: Returns this controller’s value at the given animation time (a zero-based frame number). Only meaningful if type is Controller.Type.Float.

get_int_value(time: int) → int: Returns this controller’s value at the given animation time (a zero-based frame number). Only meaningful if type is Controller.Type.Int.

get_position_value(time: int) → ArrayLike: Returns this controller’s position value at the given animation time (a zero-based frame number). Only meaningful if type is Controller.Type.Position.

get_rotation_value(time: int) → ArrayLike: Returns this controller’s rotation value at the given animation time (a zero-based frame number), encoded as a Rodrigues vector in units of radians: the axis of rotation is given by the vector’s direction, while its length gives the rotation angle around that axis. Only meaningful if type is Controller.Type.Rotation.

get_vector3_value(time: int) → ArrayLike: Returns this controller’s value at the given animation time (a zero-based frame number). Only meaningful if type is Controller.Type.Vector3. See also get_color_value(), which reinterprets the same kind of controller’s value as an RGB color.

property is_animated: bool: Indicates whether this controller’s value actually changes over the course of the animation.

set_color_value(time: int, value: tuple[float, float, float]) → None: Sets this controller’s value, given as an RGB color, at the given animation time (a zero-based frame number). Only applicable if type is Controller.Type.Vector3; equivalent to set_vector3_value().

set_float_value(time: int, value: float) → None: Sets this controller’s value at the given animation time (a zero-based frame number). Only applicable if type is Controller.Type.Float.

set_int_value(time: int, value: int) → None: Sets this controller’s value at the given animation time (a zero-based frame number). Only applicable if type is Controller.Type.Int.

set_position_value(time: int, value: ArrayLike, is_absolute: bool) → None: Sets this controller’s position value at the given animation time (a zero-based frame number). If is_absolute is True, value replaces the controller’s current value; if False, value is added to it instead. Only applicable if type is Controller.Type.Position.

set_rotation_value(time: int, value: ArrayLike, is_absolute: bool) → None: Sets this controller’s rotation value at the given animation time (a zero-based frame number), given as a Rodrigues vector in units of radians (see get_rotation_value()). If is_absolute is True, value replaces the controller’s current rotation; if False, value is applied on top of it instead. Only applicable if type is Controller.Type.Rotation.

set_scaling_value(time: int, value: Any, is_absolute: bool) → None: Sets this controller’s scaling value at the given animation time (a zero-based frame number). If is_absolute is True, value replaces the controller’s current value; if False, value is applied on top of it instead. Only applicable if type is Controller.Type.Scaling.

set_vector3_value(time: int, value: ArrayLike) → None: Sets this controller’s value at the given animation time (a zero-based frame number). Only applicable if type is Controller.Type.Vector3.

property type: Controller.Type: The kind of value managed by this controller, which determines which get_*_value/set_*_value method pair is applicable.

class ovito.nonpublic.FloatAnimationKey

Base: AnimationKey A keyframe of a float-valued KeyframeController (type Controller.Type.Float).

property value: float: The value of this animation key.

class ovito.nonpublic.IntegerAnimationKey

Base: AnimationKey A keyframe of an integer-valued KeyframeController (type Controller.Type.Int).

property value: int: The value of this animation key.

class ovito.nonpublic.KeyframeController

Base: Controller

A Controller whose value is defined by a time-sorted sequence of keys, each an instance of a concrete subclass of AnimationKey. Between two neighboring keys, the controller’s value at a given time is obtained by interpolation; outside the first/last key, the value of that nearest key is used unchanged. Use create_key() to add a new key at a given animation time.

create_key(time: int, value: Any) → AnimationKey: Creates a new animation key with the given value at the given animation time (a zero-based frame number), or updates the value of an already existing key at that exact time. Returns the (possibly newly created) AnimationKey, which is also automatically inserted into keys at the correct, time-sorted position.

property keys: Sequence[AnimationKey]: The time-sorted list of AnimationKey instances defining this controller’s value over the course of the animation. Use create_key() to add a new key.

class ovito.nonpublic.PRSTransformationController

Base: Controller

Standard implementation of a combined position/rotation/scaling transformation controller, as used for example by SceneNode.transform_ctrl. Internally, it delegates to three separate sub-controllers for position, rotation and scaling, which are combined into a single transformation matrix.

property position: Controller: The sub-controller (of type Controller.Type.Position) managing the translational component of the transformation.

property rotation: Controller: The sub-controller (of type Controller.Type.Rotation) managing the rotational component of the transformation.

property scaling: Controller: The sub-controller (of type Controller.Type.Scaling) managing the scaling component of the transformation.

class ovito.nonpublic.PipelineStatus

Reports the outcome of the most recent computation performed by an ActiveObject, e.g. a Modifier or a PipelineNode. Accessible through the object’s status field.

property text: str: A human-readable message describing the status in more detail, e.g. an error or warning message; empty if there is nothing to report.

property type: PipelineStatus.Type: Indicates whether the computation completed successfully (PipelineStatus.Type.Success), completed with a non-fatal warning (PipelineStatus.Type.Warning), or failed (PipelineStatus.Type.Error).

class ovito.nonpublic.PositionAnimationKey

Base: AnimationKey A keyframe of a position KeyframeController (type Controller.Type.Position).

property value: ArrayLike: The value of this animation key.

class ovito.nonpublic.RenderSettings

Stores general settings related to image and movie rendering, accessible through the Scene.render_settings attribute (i.e. ovito.scene.render_settings). This includes the output image/movie resolution (output_image_width/output_image_height), the range of animation frames to render (range), the output file path (output_filename), and the active rendering engine (renderer) along with its engine-specific parameters.

See also

manual:core.render_settings in the OVITO user manual

property background_color: tuple[float, float, float]

Controls the background color of the rendered image.

Default:: (1.0, 1.0, 1.0) – white

property custom_frame: int

The single animation frame to render when range is set to RenderSettings.Range.CustomFrame.

Default:: 0

property custom_range

Specifies the range of animation frames to render if range is set to CustomInterval.

Default:: (0,100)

property custom_range_end: int

The last animation frame to render when range is set to RenderSettings.Range.CustomInterval.

Default:: 100

property custom_range_start: int

The first animation frame to render when range is set to RenderSettings.Range.CustomInterval.

Default:: 0

property every_nth_frame: int

Specifies which fraction of the animation frames in the selected range is actually rendered. A value of 1 renders every frame; a value of n renders only every n-th frame. Use this to reduce the number of frames generated for extremely long animation sequences.

Default:: 1

property file_number_base: int

When rendering an animation as a sequence of image files (rather than a single movie file), OVITO appends the frame number to the output filename. This setting specifies an offset added to those frame numbers, which can be useful to collect frames from several rendering passes in one directory before combining them into one contiguous movie externally.

Default:: 0

property filename

A string specifying the file path under which the rendered image or movie should be saved.

Default:: None

property frames_per_second: int

The frame rate (FPS) used when encoding a movie file. A value less than or equal to 0 makes the renderer fall back to the frame rate given by AnimationSettings.frames_per_second of the associated Scene.anim instead. Has no effect when rendering to an image file sequence.

Default:: 0

property generate_alpha: bool

When saving the image to a file format that supports transparency information (e.g. PNG), this option will make those parts of the output image transparent which are not covered by objects.

Default:: False

property layout_separator_color: tuple

The RGB color of the separator lines drawn between viewports when layout_separators_enabled is set.

Default:: (0.5, 0.5, 0.5)

property layout_separator_width: int

The width, in pixels, of the separator lines drawn between viewports when layout_separators_enabled is set.

Default:: 2

property layout_separators_enabled: bool

Controls the visibility of separator lines drawn between the individual viewports when render_all_viewports is enabled and an entire viewport layout is rendered.

Default:: False

property output_filename: str

The output file path for the rendered image or movie. Only used if save_to_file is set to True. The filename’s extension determines the output format: if it denotes a video container format (e.g. AVI, MP4), all rendered animation frames are written to a single movie file; otherwise a sequence of image files is produced, one per frame, with the frame number automatically appended to the base filename (or substituted for a * wildcard if present).

Default:: ''

property output_image_height: int

The height of the rendered image or movie in pixels.

Default:: 480

property output_image_width: int

The width of the rendered image or movie in pixels.

Default:: 640

property range: RenderSettings.Range

Selects the animation frames to be rendered. The current animation frame and the total animation range are determined by the AnimationSettings object associated with the scene.

Possible values:

RenderSettings.Range.CurrentFrame (default): Renders a single image at the current animation time.
RenderSettings.Range.Animation: Renders a movie of the entire animation sequence.
RenderSettings.Range.CustomInterval: Renders a movie of the animation interval given by the custom_range_start/custom_range_end attributes.
RenderSettings.Range.CustomFrame: Renders a single image at the animation frame given by the custom_frame attribute.

render(viewport_config: ViewportConfiguration, anim: AnimationSettings)

Low-level method that renders one or more images using this rendering settings object, in exactly the same way as the Render active viewport button does in the OVITO GUI.

viewport_config is normally the scene’s Scene.viewport_config object, which determines which viewport (active_vp) gets rendered, or, if render_all_viewports is set, the entire layout_root_cell layout. anim is normally the scene’s Scene.anim object, which supplies the current animation frame as well as the animation interval used when range is set to render more than a single frame.

How many frames get rendered, and which ones, is controlled by range: a single frame is rendered if it is set to RenderSettings.Range.CurrentFrame or RenderSettings.Range.CustomFrame, whereas RenderSettings.Range.Animation and RenderSettings.Range.CustomInterval render every frame of the respective sequence in turn (subject to every_nth_frame), writing each one to disk if save_to_file is enabled. Regardless of how many frames were rendered, the method always returns only the last rendered frame, as a PySide6.QtGui.QImage object; use save_to_file and output_filename beforehand if the earlier frames of a sequence need to be retained.

Unlike Viewport.render_image() and Viewport.render_anim(), which are the recommended, high-level entry points for scripts, this method reads all rendering parameters, including which frames to render, from this RenderSettings object itself rather than from separate method arguments. In GUI mode, the rendered frame(s) are additionally displayed in the frame buffer window, and the operation can be canceled by the user.

property render_all_viewports: bool

Controls whether a composed output image with multiple side-by-side views is generated, one for each viewport of the current viewport layout, instead of rendering just the single active viewport.

Default:: False

property renderer: SceneRenderer

The renderer that is used to generate the image or movie. Depending on the selected renderer you can use this to set additional parameters such as the anti-aliasing level.

See the OpenGLRenderer, TachyonRenderer, OSPRayRenderer, and AnariRenderer classes for the list of parameters specific to each rendering backend.

property save_to_file: bool

Controls whether the rendered image or movie is saved to the file path given by output_filename. If False, the image is still generated and displayed in the frame buffer window (in GUI mode), but not written to disk.

Default:: False

property size

The size of the image or movie to be generated in pixels.

Default:: (640,480)

property skip_existing_images: bool

Controls whether animation frames for which the output image file already exists will be skipped when rendering an animation sequence. This flag is ignored when directly rendering to a movie file and not an image file sequence. Use this flag when the image sequence has already been partially rendered and you want to render just the missing frames.

Default:: False

property stop_on_pipeline_error: bool

Controls whether an error occurring in a data pipeline while rendering an animation sequence aborts the entire rendering process. If False, the offending frame is skipped and rendering continues with the next one.

Default:: False

class ovito.nonpublic.RotationAnimationKey

Base: AnimationKey A keyframe of a rotation KeyframeController (type Controller.Type.Rotation).

property value: ArrayLike: The value of this animation key, encoded as a Rodrigues vector in units of radians (see Controller.get_rotation_value()).

class ovito.nonpublic.ScalingAnimationKey

Base: AnimationKey A keyframe of a scaling KeyframeController (type Controller.Type.Scaling).

property value: Any: The value of this animation key.

class ovito.nonpublic.SceneNode

A node in the tree of SceneNode instances that make up the three-dimensional scene of a Scene (i.e. ovito.scene). Each such node positions and orients (translation/rotation) the output of an optionally associated pipeline within the scene, and may have any number of children sub-nodes, forming a tree that is rooted at SceneRoot (see Scene.scene_root).

Ordinary pipelines added to the scene via Pipeline.add_to_scene() each get their own SceneNode, directly parented under the scene root. Nodes without a pipeline (pipeline is None) act as pure group/container nodes and do not themselves contribute any visual output.

property children: MutableSequence[SceneNode]: The list of child nodes directly below this node in the scene tree.

delete() → None: Removes this node, and recursively all of its children, from the scene tree.

is_hidden_in_all_viewports(include_hierarchy_parent: bool) → bool: Returns whether this node is currently hidden in every interactive viewport of the scene (see is_hidden_in_viewport()).

is_hidden_in_viewport(viewport: Viewport, include_hierarchy_parent: bool) → bool: Returns whether this node has been hidden specifically in the given viewport via set_viewport_visibility(). If include_hierarchy_parent is True, the node is also considered hidden if any of its ancestor nodes in the scene tree is hidden in that viewport.

property is_selected: bool: Indicates whether this node is currently part of the scene’s selection set.

property lookat_node: SceneNode | None: The target node that this node is bound to look at (via a look-at rotation controller assigned to transform_ctrl), used for example by camera and light source nodes; or None if this node is not bound to any target.

property name: str

The name of the scene node, as it appears, for example, in the pipeline editor of the OVITO GUI. If the name is an empty string, the node will adopt the name from its pipeline, if any.

Default:: ''

property parent_node: SceneNode | None: The parent node of this node in the scene tree; or None if this is the scene_root node itself, which has no parent.

property pipeline: Pipeline | None: The Pipeline whose output is displayed by this scene node; or None if this node acts as a pure group node without any visual output of its own. Every pipeline that is part of the scene is displayed through exactly one such node, created by Pipeline.add_to_scene().

property rotation: ArrayLike

The node’s rotation relative to parent_node, specified as a Rodrigues vector in units of radians: the axis of rotation is given by the vector’s direction, while its length gives the rotation angle around that axis. This is a convenience shortcut that reads and writes the keyframe value of transform_ctrl at animation time zero, ignoring any other keyframes the controller might have.

Default:: (0.0, 0.0, 0.0)

set_viewport_visibility(viewport: Viewport, visible: bool) → None: Shows or hides this individual scene node in a specific interactive viewport window, independently of the other viewports. Corresponds to the Pipeline Visibility function found in a viewport’s context menu in the OVITO GUI. See also Pipeline.set_viewport_visibility(), which applies the same setting to every scene node associated with a given pipeline at once.

property transform_ctrl: Controller: The low-level, animatable Controller object managing this node’s position and orientation relative to its parent_node. This is normally an instance of PRSTransformationController, which is what gets created by default for every new SceneNode. The translation and rotation properties are convenience shortcuts for reading and writing this controller’s keyframe values at animation time zero.

property translation: ArrayLike

The position, in local coordinates relative to parent_node, at which the node’s pipeline output (and any children nodes) is placed in the scene. This is a convenience shortcut that reads and writes the keyframe value of transform_ctrl at animation time zero, ignoring any other keyframes the controller might have.

Default:: (0.0, 0.0, 0.0)

class ovito.nonpublic.SceneRenderer

Abstract base class for all rendering backends available in OVITO:

ovito.vis.OpenGLRenderer

ovito.vis.TachyonRenderer

ovito.vis.OSPRayRenderer

ovito.vis.AnariRenderer

See also

manual:rendering in the OVITO user manual

class ovito.nonpublic.SceneRoot

The root node of the tree of SceneNode instances that make up the three-dimensional scene, accessible through the Scene.scene_root attribute (i.e. ovito.scene.scene_root). Do not confuse this internal SceneRoot class with the public, top-level Scene object (ovito.scene), of which it is just one component.

In addition to the inherited children list (the top-level pipeline nodes of the scene), this class provides access to the scene’s anim and selection state. The former is also reachable more directly through Scene.anim.

property anim: AnimationSettings: The AnimationSettings instance associated with the scene. Equivalent to Scene.anim.

property selection: SelectionSet: The SelectionSet holding the scene nodes that are currently selected in the OVITO GUI.

class ovito.nonpublic.SelectionSet

Stores the current selection of SceneNode instances in the three-dimensional scene, i.e. the set of nodes highlighted in OVITO’s viewports, command panel, and data inspector panel. It is accessible through the SceneRoot.selection attribute of the scene root node (Scene.scene_root).

The public Scene.selected_pipeline field provides more direct access to the Pipeline associated with the currently selected SceneNode, i.e. it is equivalent to ovito.scene.scene_root.selection.first.pipeline.

property first: SceneNode | None: The first SceneNode in the nodes list; or None if the selection is empty.

property nodes: MutableSequence[SceneNode]: The list of currently selected SceneNode instances.

class ovito.nonpublic.Vector3AnimationKey

Base: AnimationKey A keyframe of a vector- or color-valued KeyframeController (type Controller.Type.Vector3).

property value: ArrayLike: The value of this animation key.

class ovito.nonpublic.ViewportConfiguration

Encapsulates the current arrangement of Viewport windows of the OVITO desktop application, accessible through the Scene.viewport_config attribute (i.e. ovito.scene.viewport_config). This includes the flat list of all existing viewports (viewports), the tree of nested ViewportLayoutCell instances describing how they are arranged on screen (layout_root_cell), and which viewport is currently active (active_vp) or maximized (maximized_vp).

You can render a ViewportConfiguration by passing it to the RenderSettings.render() method. The RenderSettings.render_all_viewports option determines whether all viewports are rendered or only the currently active one.

See also

manual:viewport_layouts in the OVITO user manual

property active_vp: Viewport | None: The viewport that is currently active. It is marked with a colored border in OVITO’s MainWindow.

get_viewport_rectangles() → list[tuple[Viewport, tuple[float, float, float, float]]]: Computes the effective rectangular area occupied by each viewport in the current layout_root_cell hierarchy. Returns a list of (viewport, rect) pairs, where each rect is a (x, y, width, height) tuple given in normalized coordinates relative to the overall layout area, with (0, 0) denoting the top-left corner and (1, 1) the bottom-right corner.

property layout_root_cell: ViewportLayoutCell: The root cell of the tree of nested ViewportLayoutCell instances that describes the current arrangement of viewport windows, see manual:viewport_layouts.

property maximized_vp: Viewport | None: The viewport that is currently maximized; or None if no viewport is maximized.

property viewports: Sequence[Viewport]: The flat list of all Viewport instances that are part of the current viewport layout, in no particular order. Use layout_root_cell to determine their on-screen arrangement.

zoom_all_when_ready() → None: Schedules all viewports in the viewports list to be zoomed to the extents of the scene once all data pipelines in the scene have been fully evaluated and their spatial extents are known. Unlike an immediate zoom operation, this defers the camera adjustment until the pending pipeline evaluations complete.

class ovito.nonpublic.ViewportLayoutCell

A single node in the tree of nested layout cells that describes how the Viewport windows of the OVITO desktop application are arranged on screen, rooted at ViewportConfiguration.layout_root_cell.

A leaf cell directly hosts a single viewport, while an interior cell instead subdivides its rectangular area, either horizontally or vertically, among its children cells according to their relative child_weights.

See also

manual:viewport_layouts in the OVITO user manual

property child_weights: list[float]: The relative sizes of the children cells along the split_direction axis. This list has the same length as children; the fraction of the available space given to a child cell equals its weight divided by the sum of all weights.

property children: MutableSequence[ViewportLayoutCell]: The list of sub-cells that this interior cell’s area is subdivided into, arranged according to split_direction and sized according to child_weights. Empty for a leaf cell that directly hosts a viewport.

property parent: ViewportLayoutCell | None: The parent cell in the layout tree that this cell is a child of; or None if this is the layout_root_cell.

property split_direction: int

For an interior cell with two or more children, specifies the axis along which this cell’s area is subdivided among them.

Possible values:

0 (None): This is a leaf cell hosting a single viewport and has no children.
1 (Horizontal): The children are arranged side by side, left to right.
2 (Vertical): The children are stacked on top of each other, top to bottom.

property viewport: Viewport | None: The viewport window occupying this cell; or None if this is an interior cell that instead subdivides its area among its children cells.

ovito.nonpublic

`ovito.nonpublic`