OpenVCAD Version 2 (Deprecated)

https://matterassembly.org/OpenVCAD-Docs/v2/
Admin
OpenVCAD is an open-source volumetric multi-material geometry compiler that enables designing...
Tokens:58,352
Snippets:489
Trust Score:6.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone OpenVCAD examples repository

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Downloads the official repository containing runnable demonstration scripts.

```bash
git clone https://github.com/MacCurdyLab/OpenVCAD-Public.git
cd OpenVCAD-Public/examples
```

--------------------------------

### Verify OpenVCAD installation

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Checks the installed version of OpenVCAD to confirm successful setup.

```python
import pyvcad as pv
print(pv.version())
```

--------------------------------

### Scale node initialization

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Examples of initializing the Scale node using different constructor overloads.

```python
>>> from libvcad import pyvcad as pv
>>> rect_prism = pv.RectPrism(pv.vec3(0, 0, 0), pv.vec3(2, 2, 2), 1)
>>> scale = pv.Scale()
>>> scale.set_child(rect_prism)
```

```python
>>> from libvcad import pyvcad as pv
>>> rect_prism = pv.RectPrism(pv.vec3(0, 0, 0), pv.vec3(2, 2, 2), 1)
>>> scale = pv.Scale(2.0, 2.0, 2.0)
>>> scale.set_child(rect_prism)
```

--------------------------------

### Create ConformalMap nodes

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Examples of initializing ConformalMap with different configurations for base surfaces and patterns.

```python
>>> from libvcad import pyvcad as pv
>>> base_surface = pv.Sphere(pv.Vec3(0, 0, 0), 10.0, 1)
>>> pattern = pv.RectPrism(pv.Vec3(-1, -1, -0.2), pv.Vec3(1, 1, 0.2), 2)
>>> conformal = pv.ConformalMap()
>>> conformal.set_left(base_surface)
>>> conformal.set_right(pattern)
```

```python
>>> from libvcad import pyvcad as pv
>>> base_surface = pv.Sphere(pv.Vec3(0, 0, 0), 10.0, 1)
>>> pattern = pv.RectPrism(pv.Vec3(-1, -1, -0.2), pv.Vec3(1, 1, 0.2), 2)
>>> conformal = pv.ConformalMap(base_surface, pattern)
```

```python
>>> from libvcad import pyvcad as pv
>>> base_surface = pv.Sphere(pv.Vec3(0, 0, 0), 10.0, 1)
>>> pattern = pv.RectPrism(pv.Vec3(-1, -1, -0.2), pv.Vec3(1, 1, 0.2), 2)
>>> ref_direction = pv.Vec3(0, 1, 0)  # Use Y-axis as reference
>>> conformal = pv.ConformalMap(base_surface, pattern, ref_direction)
```

--------------------------------

### Create BBoxUnion nodes

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Examples of initializing BBoxUnion with children, a smoothing radius, or both.

```python
>>> from libvcad import pyvcad as pv
>>> children = [child1, child2]
>>> union_node = pv.BBoxUnion(children)
```

```python
>>> from libvcad import pyvcad as pv
>>> union_node = pv.BBoxUnion(1.0)
```

```python
>>> from libvcad import pyvcad as pv
>>> children = [child1, child2]
>>> union_node = pv.BBoxUnion(1.0, children)
```

--------------------------------

### Install OpenVCAD via pip

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Installs the specific legacy version 2.3.8 of OpenVCAD.

```bash
pip install OpenVCAD==2.3.8
```

--------------------------------

### Start Build Worker

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Initializes and starts a background thread for building VTK objects.

```python
def _start_worker(self, gen, vcad_object, materials, cfg):
    worker = _BuildWorker(self, gen, vcad_object, materials, cfg)
    t = threading.Thread(target=worker.run, name=f"VTKBuild-{gen}", daemon=True)
    self._worker_thread = t
    t.start()
```

--------------------------------

### Rotate node initialization

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Examples of initializing the Rotate node using different constructor overloads.

```python
>>> from libvcad import pyvcad as pv
>>> rect_prism = pv.RectPrism(pv.vec3(0, 0, 0), pv.vec3(2, 2, 2), 1)
>>> rotate = pv.Rotate()
>>> rotate.set_child(rect_prism)
```

```python
>>> from libvcad import pyvcad as pv
>>> pitch = 30
>>> yaw = 45
>>> roll = 60
>>> around = pv.vec3(1, 1, 1)
>>> rect_prism = pv.RectPrism(pv.vec3(0, 0, 0), pv.vec3(2, 2, 2), 1)
>>> rotate = pv.Rotate(pitch, yaw, roll, around)
>>> rotate.set_child(rect_prism)
```

```python
>>> from libvcad import pyvcad as pv
>>> pitch = 30
>>> yaw = 45
>>> roll = 60
>>> around = pv.vec3(1, 1, 1)
>>> rect_prism = pv.RectPrism(pv.vec3(0, 0, 0), pv.vec3(2, 2, 2), 1)
>>> rotate = pv.Rotate(pitch, yaw, roll, around, rect_prism)
```

--------------------------------

### Initialize a Strut

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Creates a strut defined by start and end points, radius, and material ID.

```python
>>> from libvcad import pyvcad as pv
>>> start = pv.vec3(0, 0, 0)
>>> end = pv.vec3(1, 1, 1)
>>> strut = pv.Strut(start, end, 0.5, 1)
```

--------------------------------

### Upgrade pip and install OpenVCAD

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Ensures pip is up to date before installing the OpenVCAD package.

```bash
pip install --upgrade pip
pip install OpenVCAD==2.3.8
```

--------------------------------

### Get Render Mode

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Retrieves the current rendering mode.

```python
    def get_render_mode(self):
        return self.render_mode
```

--------------------------------

### Initialize VTKRenderPipeline

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Sets up the rendering environment, interactor styles, and default progress callbacks.

```python
def __init__(self, event_target: wx.Window, use_default_interaction=True, render_window=None):
    self.event_target = event_target

    # Rendering resources
    self.renderer = vtkRenderer()
    self.render_window = render_window or vtkRenderWindow()
    self.render_window.AddRenderer(self.renderer)

    # Interactor style (GUI thread only)
    if use_default_interaction:
        interactor = self.render_window.GetInteractor()
        if interactor is not None:
            style = vtkInteractorStyleTrackballCamera()
            interactor.SetInteractorStyle(style)

    self.corner_axis_widget = self._create_corner_axis_widget()

    # Render state
    self.render_mode = "iso_surface"
    self.quality_profile = "low"
    self.use_orthogonal_projection = False
    self.use_volume_shading = False
    self.use_volume_blending = True

    self._show_bounding_box = False
    self.bbox_actor = None
    self.min_pt_text = None
    self.max_pt_text = None
    self._show_origin = False
    self.origin_actor = None

    self.vcad_object = None
    self.materials = None
    self.voxel_size = None

    self.current_volume = None
    self.current_iso_surface = None

    # Async build state
    self._gen = 0
    self._pending_reset_camera = False
    self._worker_thread = None
    self._worker_lock = threading.Lock()

    # Default progress callbacks -> post wx events
    self.iso_surface_sample_progress_callback = lambda p: self._post(IsoSampleEvent, progress=float(p))
    self.iso_surface_contouring_progress_callback = lambda p: self._post(IsoContourEvent, progress=float(p))
    self.iso_surface_coloring_progress_callback = lambda p: self._post(IsoColorEvent, progress=float(p))
    self.volume_sample_progress_callback = lambda p: self._post(VolSampleEvent, progress=float(p))
```

--------------------------------

### Create project directory

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Initializes a new directory for your OpenVCAD project.

```bash
mkdir my_openvcad_project
cd my_openvcad_project
```

--------------------------------

### Get Node Type

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/tree.html

Returns the classification of the node as a string.

```python
>>> from libvcad import pyvcad as pv
>>> sphere = pv.Sphere()
>>> node_type = sphere.type() # Should return 'leaf'
```

--------------------------------

### Create and activate virtual environment

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/install.md.txt

Sets up an isolated Python environment for the project.

```bash
# macOS / Linux
python3 -m venv venv
source venv/bin/activate

# Windows
python -m venv venv
venv\Scripts\activate
```

--------------------------------

### Initialize Point2

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/geometry.html

Demonstrates creating a 2D point at the origin or with specific coordinates.

```python
>>> p = Point2()
>>> print(f'({p.x()}, {p.y()})')
(0.0, 0.0)
```

```python
>>> p = Point2(1.0, 2.0)
>>> print(f'({p.x()}, {p.y()})')
(1.0, 2.0)
```

--------------------------------

### Initialize and access Vec4 components

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/geometry.html

Demonstrates creating a Vec4 instance and accessing its color components.

```python
>>> v = Vec4(1.0, 0.0, 0.0, 1.0)  # Red color with full opacity
>>> print(f'({v.r}, {v.g}, {v.b}, {v.a})')
(1.0, 0.0, 0.0, 1.0)
```

--------------------------------

### Create a basic 3D object with OpenVCAD

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_sources/getting-started.md.txt

Initializes a simple 10mm cube centered at the origin using the default red material.

```python
import pyvcad as pv
import pyvcad_rendering as viz

materials = pv.default_materials

center_point = pv.Vec3(0, 0, 0)
dimensions = pv.Vec3(10, 10, 10)

root = pv.RectPrism(center_point, dimensions, materials.id("red"))

viz.Render(root, materials)
```

--------------------------------

### Strut Class

Source: https://matterassembly.org/OpenVCAD-Docs/v2/cpp-api/libvcad-tree-leaves.html

A leaf node representing a cylindrical strut defined by start and end points.

```APIDOC
## Strut(glm::vec3 start, glm::vec3 end, double radius, uint8_t material = 1)

### Description
Constructor for a strut leaf node.

### Parameters
- **start** (glm::vec3) - Required - The start of the strut.
- **end** (glm::vec3) - Required - The end of the strut.
- **radius** (double) - Required - The radius of the strut.
- **material** (uint8_t) - Optional - The material of the strut.
```

--------------------------------

### Initialize Rendering Progress Dialog

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Handles the creation and configuration of a wx.ProgressDialog based on the current render mode (volumetric vs iso-surface).

```python
def on_build_started(self, _=0):
        self._stop_finalizing_pulse()
        is_volumetric = self.render_pipeline.get_render_mode() == "volumetric"
        base_max = 100 if is_volumetric else 300
        tail = max(1, getattr(self, "_progress_tail", 1))
        self._progress_tail = tail
        maximum = base_max + tail
        # Reserve a slot so wx.PD_AUTO_HIDE waits for explicit finish
        # Reset monotonic tracker for a new build
        self._last_progress = 0
        self._finalizing_shown = False
        self._build_finished_early = False
        # Max=300 for iso-surface (3 phases), 100 for volumetric (1 phase)
        self.progress_dialog = wx.ProgressDialog(
            "Rendering…",
            "Initializing…",
            maximum=maximum,
            parent=self,
            style=wx.PD_APP_MODAL | wx.PD_AUTO_HIDE | wx.PD_CAN_ABORT
        )
        # If the build finished while the dialog was being created (e.g. on Windows event loop pumping)
        if self._build_finished_early:
            self.progress_dialog.Destroy()
            self.progress_dialog = None
            return

        self.progress_dialog.Update(0, "Initializing…")
```

--------------------------------

### Initialize Export Frame UI

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/export_frame.html

Sets up the confirmation panel, navigation buttons, and initial layout for the export wizard.

```python
# Step 4: Confirmation
        confirmation_panel = wx.Panel(self.book)
        confirmation_sizer = wx.BoxSizer(wx.VERTICAL)
        self.confirmation_text = wx.StaticText(confirmation_panel, label="")
        confirmation_sizer.Add(self.confirmation_text, 0, wx.ALL, 5)
        self.open_folder_button = wx.Button(confirmation_panel, label="Open Output Folder")
        self.open_folder_button.Bind(wx.EVT_BUTTON, self.on_open_folder)
        self.open_folder_button.Hide()
        confirmation_sizer.Add(self.open_folder_button, 0, wx.ALL, 5)
        confirmation_panel.SetSizer(confirmation_sizer)
        self.book.AddPage(confirmation_panel, "Confirmation")

        self.sizer.Add(self.book, 1, wx.EXPAND | wx.ALL, 25)

        self.btn_sizer = wx.BoxSizer(wx.HORIZONTAL)
        self.back_btn = wx.Button(self.panel, label="Back")
        self.next_btn = wx.Button(self.panel, label="Next")
        self.back_btn.Bind(wx.EVT_BUTTON, self.on_back)
        self.next_btn.Bind(wx.EVT_BUTTON, self.on_next)
        self.btn_sizer.Add(self.back_btn, 0, wx.ALL, 5)
        self.btn_sizer.Add(self.next_btn, 0, wx.ALL, 5)
        self.sizer.Add(self.btn_sizer, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.BOTTOM, 10)

        self.update_buttons()
        self.Centre()
        self.Show()
        self.export_file_path = None
```

--------------------------------

### System Background Initialization

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Internal method to set VTK background based on system appearance, noting Windows limitations.

```python
    def _apply_bg_from_system(self):
        """Set the VTK background based on system appearance (dark vs light).
        Do not allow dark mode on Windows because wxPython does not support dark mode yet
        """
        import sys
```

--------------------------------

### pyvcad.Strut

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

A leaf node representing a strut defined by start and end points, radius, and material ID.

```APIDOC
## pyvcad.Strut

### Description
Creates a strut geometric primitive between two points.

### Constructor
`__init__(start, end, radius, material)`
- **start** (Vec3) - The start point of the strut.
- **end** (Vec3) - The end point of the strut.
- **radius** (float) - The radius of the strut.
- **material** (int) - The material ID (default: 1).
```

--------------------------------

### Initialize Voxels

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Creates a voxel grid either from an existing VDB file or as an empty grid.

```python
>>> from libvcad import pyvcad as pv
>>> material_defs = pv.MaterialDefs()
>>> voxels = pv.Voxels('path/to/voxelgrid.vdb', pv.vec3(0.1, 0.1, 0.1), pv.vec3(0, 0, 0), material_defs)
```

```python
>>> from libvcad import pyvcad as pv
>>> voxels = pv.Voxels(pv.vec3(0.1, 0.1, 0.1), pv.vec3(0, 0, 0))
```

--------------------------------

### VTPCompiler::compute_vtp_parameters

Source: https://matterassembly.org/OpenVCAD-Docs/v2/cpp-api/libvcad-compilers-writers.html

Calculates VTP parameters based on start and end points, optionally considering material distribution or specific star values.

```APIDOC
## std::tuple<double, double, double> VTPCompiler::compute_vtp_parameters(glm::vec3 start_pt, glm::vec3 end_pt)

### Description
Computes VTP parameters for a given segment defined by start and end points.

### Parameters
- **start_pt** (glm::vec3) - Segment start point
- **end_pt** (glm::vec3) - Segment end point

### Returns
- **std::tuple<double, double, double>** - Calculated VTP parameters
```

--------------------------------

### Initialize a Sphere

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Demonstrates different constructor overloads for creating a sphere primitive.

```python
>>> from libvcad import pyvcad as pv
>>> sphere = pv.Sphere()
```

```python
>>> from libvcad import pyvcad as pv
>>> sphere = pv.Sphere(0, 0, 0, 5, 1)
```

```python
>>> from libvcad import pyvcad as pv
>>> center = pv.vec3(0, 0, 0)
>>> sphere = pv.Sphere(center, 5, 1)
```

--------------------------------

### Configure wxPython Menu and Event Bindings

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Sets up the application menu structure, including volumetric options and help menus, and binds menu events to their respective handler methods.

```python
# Volumetric Options sub-menu (disabled by default)
        self.volume_menu = wx.Menu()
        self.item_volumetric_blending = self.volume_menu.AppendCheckItem(wx.ID_ANY, "Volumetric Blending")
        self.item_volumetric_shading = self.volume_menu.AppendCheckItem(wx.ID_ANY, "Volumetric Shading")
        self.item_volumetric_blending.Check(True)  # default enabled

        # Keep handle to the submenu item so we can enable/disable
        self.volume_menu_item = object_menu.AppendSubMenu(self.volume_menu, "Volumetric Options")
        self.volume_menu_item.Enable(False)

        menubar.Append(object_menu, "&Object")

        # ===== Help =====
        help_menu = wx.Menu()
        self.item_about = help_menu.Append(wx.ID_ANY, "About")
        help_menu.AppendSeparator()
        self.item_wiki = help_menu.Append(wx.ID_ANY, "Wiki")
        self.item_docs = help_menu.Append(wx.ID_ANY, "Library Documentation")
        self.item_getting_started = help_menu.Append(wx.ID_ANY, "Getting Started")
        help_menu.AppendSeparator()
        self.item_report_bug = help_menu.Append(wx.ID_ANY, "Report a Bug")
        menubar.Append(help_menu, "&Help")

        self.SetMenuBar(menubar)

        # ----- Bind menu events -----
        # File
        self.Bind(wx.EVT_MENU, self.on_screenshot, self.item_screenshot)

        # View
        self.Bind(wx.EVT_MENU, self.on_toggle_show_origin, self.item_show_origin)
        self.Bind(wx.EVT_MENU, self.on_toggle_ortho_projection, self.item_ortho_proj)
        self.Bind(wx.EVT_MENU, self.on_reset_camera, self.item_reset_camera)
        self.Bind(wx.EVT_MENU, self.on_set_top_view, self.item_top_view)
        self.Bind(wx.EVT_MENU, self.on_set_bottom_view, self.item_bottom_view)
        self.Bind(wx.EVT_MENU, self.on_set_side_view, self.item_side_view)
        self.Bind(wx.EVT_MENU, self.on_set_corner_view, self.item_corner_view)

        # Quality radio group → one handler, read which is checked
        self.Bind(wx.EVT_MENU, self._on_quality_any, self.item_quality_low)
        self.Bind(wx.EVT_MENU, self._on_quality_any, self.item_quality_medium)
        self.Bind(wx.EVT_MENU, self._on_quality_any, self.item_quality_high)
        self.Bind(wx.EVT_MENU, self._on_quality_any, self.item_quality_ultra)

        # Object → Mode radios
        self.Bind(wx.EVT_MENU, self._on_mode_any, self.item_iso_surface)
        self.Bind(wx.EVT_MENU, self._on_mode_any, self.item_volumetric)

        # Object toggles
        self.Bind(wx.EVT_MENU, self.on_toggle_show_bbox, self.item_show_bbox)
        self.Bind(wx.EVT_MENU, self.on_toggle_volumetric_blending, self.item_volumetric_blending)
        self.Bind(wx.EVT_MENU, self.on_toggle_volumetric_shading, self.item_volumetric_shading)

        # Help
        self.Bind(wx.EVT_MENU, self.on_about, self.item_about)
        self.Bind(wx.EVT_MENU, self.on_wiki, self.item_wiki)
        self.Bind(wx.EVT_MENU, self.on_docs, self.item_docs)
        self.Bind(wx.EVT_MENU, self.on_getting_started, self.item_getting_started)
        self.Bind(wx.EVT_MENU, self.on_report_bug, self.item_report_bug)

        self.Centre()
        self.Show()

        # Update if the OS theme changes while the app is running
        self.Bind(wx.EVT_SYS_COLOUR_CHANGED, self._on_sys_colour_changed)

        # Initial render
        self.render_pipeline.update_vcad_object(self.vcad_object, self.materials)

        # Apply background based on current system appearance
        self._apply_bg_from_system()
```

--------------------------------

### Retrieve Resources Path

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/overview.html

Demonstrates how to obtain the path to the resources directory, which varies by operating system.

```python
>>> path = resources_path()
>>> print(path)
'../../Resources/' on Mac OS    '' on Windows and Linux
```

--------------------------------

### Tile a geometry

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Demonstrates different ways to initialize a Tile node for repeating geometry in a grid pattern.

```python
>>> from libvcad import pyvcad as pv
>>> tile = pv.Tile()
```

```python
>>> from libvcad import pyvcad as pv
>>> rect_prism = pv.RectPrism(pv.Vec3(0, 0, 0), pv.Vec3(2, 2, 2), 1)
>>> tile = pv.Tile(rect_prism)
```

```python
>>> from libvcad import pyvcad as pv
>>> tile = pv.Tile(1.0, 1.0, 1.0)
```

--------------------------------

### Initialize a PointMap

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Creates a PointMap instance using a mesh file, displacement field, and defined material functions.

```python
>>> from libvcad import pyvcad as pv
>>> functions = ['x + y + z', 'x * y * z']
>>> materials = [1, 2]
>>> point_map = pv.PointMap('path/to/meshfile.inp', 'path/to/displacementfile.csv', functions, materials, True)
```

--------------------------------

### Initialize Difference node

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Demonstrates various ways to instantiate a Difference node, including default, child-based, and smooth-blended constructors.

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> left_sphere = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> right_sphere = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> difference = pv.Difference()
>>> difference.set_left(left_sphere)
>>> difference.set_right(right_sphere)
```

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> left_sphere = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> right_sphere = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> difference = pv.Difference(left_sphere, right_sphere)
```

```python
>>> from libvcad import pyvcad as pv
>>> smooth_diff = pv.Difference(1.0)
>>> smooth_diff.set_left(left_sphere)
>>> smooth_diff.set_right(right_sphere)
```

```python
>>> from libvcad import pyvcad as pv
>>> left_sphere = pv.Sphere(pv.Vec3(-2, 0, 0), 3, 1)
>>> right_sphere = pv.Sphere(pv.Vec3(2, 0, 0), 3, 1)
>>> smooth_diff = pv.Difference(1.0, left_sphere, right_sphere)
```

--------------------------------

### render(vcad_object, materials)

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render.html

Initializes a wxPython application and displays the RenderFrame for the provided vcad_object and materials.

```APIDOC
## render(vcad_object, materials)

### Description
Initializes a wxPython application and displays the RenderFrame for the provided vcad_object and materials. This function starts the application's main loop.

### Parameters
- **vcad_object** (object) - The vcad object to be rendered.
- **materials** (object) - The materials configuration to apply to the rendering.

### Usage
```python
from pyvcad_rendering.render import render
render(my_vcad_object, my_materials)
```
```

--------------------------------

### RenderFrame.__init__

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad_rendering/render_frame.html

Initializes a new instance of the RenderFrame class to display a VCAD object.

```APIDOC
## RenderFrame.__init__(vcad_object, materials, parent=None, title='OpenVCAD Renderer')

### Description
Initializes the rendering frame with the specified VCAD object and materials.

### Parameters
- **vcad_object** (object) - Required - The object to be rendered.
- **materials** (object) - Required - The materials associated with the object.
- **parent** (object) - Optional - The parent window or frame.
- **title** (str) - Optional - The title of the rendering window.
```

--------------------------------

### prepare(voxel_size, interior_bandwidth, exterior_bandwidth)

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/tree.html

Performs pre-evaluation operations for the tree.

```APIDOC
## prepare(voxel_size, interior_bandwidth, exterior_bandwidth)

### Description
Performs any single-run operations that need to be done before the tree is evaluated.

### Parameters
- **voxel_size** (Vec3) - Required - The size of the voxels.
- **interior_bandwidth** (double) - Required - The interior bandwidth.
- **exterior_bandwidth** (double) - Required - The exterior bandwidth.
```

--------------------------------

### Create a Tile node

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Initializes a Tile node using a RectPrism as the base geometry.

```python
>>> from libvcad import pyvcad as pv
>>> rect_prism = pv.RectPrism(pv.Vec3(0, 0, 0), pv.Vec3(2, 2, 2), 1)
>>> tile = pv.Tile(1.0, 1.0, 1.0, rect_prism)
```

--------------------------------

### Create a Union node

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Shows various ways to initialize a Union node, including default, distribution-aware, and smooth blending constructors.

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> union_node = pv.Union()
>>> union_node.add_child(sphere1)
>>> union_node.add_child(sphere2)
```

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> union_node = pv.Union(True)
>>> union_node.add_child(sphere1)
>>> union_node.add_child(sphere2)
```

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> union_node = pv.Union(True, [sphere1, sphere2])
```

```python
>>> from libvcad import pyvcad as pv
>>> sphere1 = pv.Sphere(pv.Vec3(-2, 0, 0), 3, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(2, 0, 0), 3, 1)
>>> smooth_union = pv.Union(1.0, False)
>>> smooth_union.add_child(sphere1)
>>> smooth_union.add_child(sphere2)
```

```python
>>> from libvcad import pyvcad as pv
>>> sphere1 = pv.Sphere(pv.Vec3(-2, 0, 0), 3, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(2, 0, 0), 3, 1)
>>> smooth_union = pv.Union(1.0, False, [sphere1, sphere2])
```

--------------------------------

### Initialize FGrade with Python functions and child

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/material_nodes.html

Create an FGrade node using Python functions and a child node directly in the constructor.

```python
>>> import pyvcad as pv
>>> materials = pv.MaterialDefs('configs/default.json')
>>> bar = pv.RectPrism(pv.Vec3(0,0,0), pv.Vec3(100,50,10), materials.id('gray'))
>>> def func_a(x, y, z, rho, phic, r, theta, phis, d):
...     return x/100 + 0.5
>>> def func_b(x, y, z, rho, phic, r, theta, phis, d):
...     return -x/100 + 0.5
>>> root = pv.FGrade([func_a, func_b], [materials.id('red'), materials.id('blue')], False, bar)
```

--------------------------------

### Create Corner Axis Widget

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Sets up an orientation marker widget for the render window.

```python
    def _create_corner_axis_widget(self):
        axes = vtkAxesActor()
        widget = vtkOrientationMarkerWidget()
        widget.SetOrientationMarker(axes)
        widget.SetInteractor(self.render_window.GetInteractor())
        widget.SetViewport(0.8, 0.8, 1.0, 1.0)
        widget.SetEnabled(1)
        widget.InteractiveOff()
        return widget
```

--------------------------------

### Handle Web Navigation Events

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Opens external documentation and support links in the default web browser.

```python
    def on_wiki(self, _evt=None):
        webbrowser.open("https://github.com/MacCurdyLab/OpenVCAD-Public/wiki")

    def on_docs(self, _evt=None):
        webbrowser.open("https://matterassembly.org/pyvcad")

    def on_getting_started(self, _evt=None):
        webbrowser.open("https://github.com/MacCurdyLab/OpenVCAD-Public/wiki/Getting-Started-with-OpenVCAD")

    def on_report_bug(self, _evt=None):
        webbrowser.open("https://github.com/MacCurdyLab/OpenVCAD-Public/issues/new?template=bug_report.md")
```

--------------------------------

### pyvcad.GraphLattice.__init__

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Constructor for creating a graph lattice structure.

```APIDOC
## pyvcad.GraphLattice.__init__(edges, radius, material)

### Description
Creates a graph lattice defined by a set of edges and a strut radius.

### Parameters
- **edges** (List[Tuple[Vec3, Vec3]]) - Required - The edges of the lattice.
- **radius** (float) - Required - The radius of the struts.
- **material** (uint8_t) - Required - The material ID of the lattice.

### Example
```python
from libvcad import pyvcad as pv
edges = [(pv.vec3(0, 0, 0), pv.vec3(1, 1, 1))]
graph_lattice = pv.GraphLattice(edges, 0.5, 1)
```
```

--------------------------------

### MeshCompiler.__init__

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad_compilers/brep.html

Constructor for the MeshCompiler class.

```APIDOC
## MeshCompiler.__init__(root, voxel_size, output_directory, file_prefix, num_iso_slices)

### Description
Initializes a new instance of the MeshCompiler.

### Parameters
- **root** (Node) - The root node of the tree.
- **voxel_size** (Vec3) - The size of the voxel.
- **output_directory** (str) - The output directory.
- **file_prefix** (str) - The file prefix.
- **num_iso_slices** (SupportsInt) - The number of iso slices.
```

--------------------------------

### pyvcad_rendering.render.Render

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad_rendering/render.html

Initializes a Render object for a given vcad object and materials.

```APIDOC
## pyvcad_rendering.render.Render(vcad_object, materials)

### Description
Initializes a new Render instance to process the provided vcad object with the specified materials.

### Parameters
- **vcad_object** (object) - Required - The vcad object to be rendered.
- **materials** (object) - Required - The materials to apply during rendering.
```

--------------------------------

### Handle Quality and View Settings

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Updates rendering quality profiles and camera view orientations.

```python
    def _on_quality_any(self, evt):
        quality_map = { # Map checked item -> quality string
            self.item_quality_low.GetId(): "low",
            self.item_quality_medium.GetId(): "medium",
            self.item_quality_high.GetId(): "high",
            self.item_quality_ultra.GetId(): "ultra",
        }
        quality = quality_map.get(evt.GetId(), "low")
        self.on_quality_changed(quality)

    def on_quality_changed(self, quality: str):
        self.render_pipeline.set_quality_profile(quality)

    def on_set_top_view(self, _evt=None):
       self.render_pipeline.set_top_view()

    def on_set_bottom_view(self, _evt=None):
        self.render_pipeline.set_bottom_view()

    def on_set_side_view(self, _evt=None):
        self.render_pipeline.set_side_view()

    def on_set_corner_view(self, _evt=None):
        self.render_pipeline.set_corner_view()
```

--------------------------------

### Create Volume from Object

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Generates a vtkVolume with transfer functions for color and opacity.

```python
    def _create_volume_from_object(self, vcad_object, materials, voxel_size):
        volume_data = self._create_image_data_from_object(vcad_object, voxel_size, materials)

        volume_mapper = vtkSmartVolumeMapper()
        volume_mapper.SetInputData(volume_data)

        color_transfer_function = vtkColorTransferFunction()
        color_transfer_function.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
        color_transfer_function.AddRGBPoint(255.0, 1.0, 1.0, 1.0)

        opacity_transfer_function = vtkPiecewiseFunction()
        opacity_transfer_function.AddPoint(0.0, 0.0)
        opacity_transfer_function.AddPoint(10.0, 0.2)
        opacity_transfer_function.AddPoint(128.0, 0.4)
        opacity_transfer_function.AddPoint(200.0, 0.8)
        opacity_transfer_function.AddPoint(255.0, 1.0)

        volume_property = vtkVolumeProperty()
        volume_property.SetColor(color_transfer_function)
        volume_property.SetScalarOpacity(opacity_transfer_function)
        volume_property.SetInterpolationTypeToLinear()
        volume_property.IndependentComponentsOff()

        volume = vtkVolume()
        volume.SetMapper(volume_mapper)
        volume.SetProperty(volume_property)
        return volume
```

--------------------------------

### Create a GraphLattice node

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Initializes a GraphLattice with a specified type, size, strut radius, and material ID.

```python
>>> from libvcad import pyvcad as pv
>>> size = pv.vec3(1, 1, 1)
>>> graph_lattice = pv.GraphLattice(pv.LatticeType.BodyCenteredCubic, size, 0.5, 1)
```

--------------------------------

### GrayscaleCompiler Constructor

Source: https://matterassembly.org/OpenVCAD-Docs/v2/cpp-api/libvcad-compilers-vat.html

Initializes a new instance of the GrayscaleCompiler with the specified node tree, voxel dimensions, material settings, and output configuration.

```APIDOC
## GrayscaleCompiler(const std::shared_ptr<Node> &m_root, glm::vec3 voxel_size, glm::vec3 printer_volume, uint8_t low_material, uint8_t high_material, const std::string &output_directory, const std::string &file_prefix)

### Description
Constructs the compiler object required to process voxel data into output files.

### Parameters
- **m_root** (std::shared_ptr<Node>) - The root node of the voxel tree.
- **voxel_size** (glm::vec3) - The dimensions of a single voxel.
- **printer_volume** (glm::vec3) - The total volume of the printer.
- **low_material** (uint8_t) - The material ID for low-density areas.
- **high_material** (uint8_t) - The material ID for high-density areas.
- **output_directory** (std::string) - The directory path where output files will be saved.
- **file_prefix** (std::string) - The prefix for generated filenames.
```

--------------------------------

### Populate Voxel Grid with PNG Stack

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Populates a grid from a directory of sequentially named PNG files.

```python
>>> from libvcad import pyvcad as pv
>>> voxels.populate_with_png_stack('path/to/png_stack', pv.vec3(0, 0, 0), pv.vec3(0.1, 0.1, 0.1))
```

--------------------------------

### Handle UI Actions

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/render_frame.html

Methods for triggering file dialogs for screenshots and displaying application information.

```python
    def on_screenshot(self, _evt=None):
        with wx.FileDialog(
            self,
            message="Save Screenshot",
            defaultFile="screenshot.png",
            wildcard="PNG Image (*.png)|*.png",
            style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT
        ) as dlg:
            if dlg.ShowModal() == wx.ID_OK:
                path = dlg.GetPath()
                self.render_pipeline.take_screenshot(path)
```

```python
    def on_about(self, _evt=None):
        year = datetime.date.today().year
        try:
            import pyvcad as pv
            vcad_version = pv.version()
        except Exception:
            vcad_version = "unknown"

        dlg = wx.Dialog(self, title="About OpenVCAD Renderer")
        
        # Main sizer for the dialog content
        main_sizer = wx.BoxSizer(wx.VERTICAL)
        
        # Title
        title_font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
        title_font.SetPointSize(title_font.GetPointSize() + 4)
        title_font.SetWeight(wx.FONTWEIGHT_BOLD)
        title_text = wx.StaticText(dlg, label="OpenVCAD Renderer")
        title_text.SetFont(title_font)
        main_sizer.Add(title_text, 0, wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM, 15)
```

--------------------------------

### FGrade.__init__

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/material_nodes.html

Constructor for the FGrade node, which creates a material distribution based on volume fraction functions.

```APIDOC
## FGrade.__init__(functions, materials, prob_mode, child=None)

### Description
Creates an FGrade node with a list of lambda functions, corresponding materials, a mode, and an optional child node.

### Parameters
- **functions** (Sequence[Callable]) - Required - A list of lambda functions that are volume fraction functions. They must sum to one and take xyz, cylindrical, and spherical coordinates as parameters.
- **materials** (Sequence[int]) - Required - A list of material IDs corresponding to the functions.
- **prob_mode** (bool) - Required - If true, the node runs in probability mode; if false, it runs in threshold mode.
- **child** (Node) - Optional - The child node to apply the material distribution to.
```

--------------------------------

### Initialize FGrade with Python functions

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/material_nodes.html

Create an FGrade node using Python functions and set the child node separately.

```python
>>> import pyvcad as pv
>>> materials = pv.MaterialDefs('configs/default.json')
>>> bar = pv.RectPrism(pv.Vec3(0,0,0), pv.Vec3(100,50,10), materials.id('gray'))
>>> def func_a(x, y, z, rho, phic, r, theta, phis):
...     return x/100 + 0.5
>>> def func_b(x, y, z, rho, phic, r, theta, phis):
...     return -x/100 + 0.5
>>> root = pv.FGrade([func_a, func_b], [materials.id('red'), materials.id('blue')], False)
>>> root.set_child(bar)
```

--------------------------------

### Write INP file with configuration path

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad_compilers/writers.html

Writes an INP file using a path to a material definition configuration file.

```python
>>> writer.write('/tmp/mesh.inp', root, pv.Vec3(1, 1, 1), 'configs/default.json', False)
```

--------------------------------

### Exporting vcad objects with wxPython

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/export.html

Initializes a wx.App and displays the ExportFrame to handle vcad object exports.

```python
import wx

from .export_frame import ExportFrame



[docs]
def export(vcad_object, materials):
    app = wx.App(False)
    app.frame = ExportFrame(vcad_object, materials)
    app.MainLoop()



[docs]
def Export(vcad_object, materials):
    export(vcad_object, materials)

__all__ = ["export", "Export"]
```

--------------------------------

### Initialize Intersection node

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/composition.html

Demonstrates various ways to instantiate an Intersection node, including default, distribution-based, and list-based constructors.

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> intersection = pv.Intersection()
>>> intersection.add_child(sphere1)
>>> intersection.add_child(sphere2)
```

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> intersection = pv.Intersection(True)
>>> intersection.add_child(sphere1)
>>> intersection.add_child(sphere2)
```

```python
>>> from libvcad import pyvcad as pv
>>> radius = 5
>>> sphere1 = pv.Sphere(pv.Vec3(-radius/2, 0, 0), radius, 1)
>>> sphere2 = pv.Sphere(pv.Vec3(radius/2, 0, 0), radius, 1)
>>> intersection = pv.Intersection(True, [sphere1, sphere2])
```

--------------------------------

### Take Screenshot

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/vtk_pipeline_wx.html

Captures the current render window to a PNG file, temporarily hiding UI elements like the origin and bounding box.

```python
def take_screenshot(self, path: str):
    self.corner_axis_widget.SetEnabled(False)

    origin_was_visible = self._show_origin
    if origin_was_visible and self.origin_actor:
        self.renderer.RemoveActor(self.origin_actor)
        self.render_window.Render()

    bbox_was_visible = self._show_bounding_box
    if bbox_was_visible and self.bbox_actor:
        self.renderer.RemoveActor(self.bbox_actor)
        self.renderer.RemoveActor2D(self.min_pt_text)
        self.renderer.RemoveActor2D(self.max_pt_text)
        self.render_window.Render()

    window_to_image_filter = vtkWindowToImageFilter()
    window_to_image_filter.SetInput(self.render_window)
    window_to_image_filter.SetScale(2)
    window_to_image_filter.SetInputBufferTypeToRGBA()
    window_to_image_filter.ReadFrontBufferOff()
    window_to_image_filter.Update()

    writer = vtkPNGWriter()
    writer.SetFileName(path)
    writer.SetInputConnection(window_to_image_filter.GetOutputPort())
    writer.SetFileDimensionality(2)
    writer.Write()

    self.corner_axis_widget.SetEnabled(False)

    if origin_was_visible and self.origin_actor:
        self.renderer.AddActor(self.origin_actor)
        self.render_window.Render()

    if bbox_was_visible and self.bbox_actor:
        self.renderer.AddActor(self.bbox_actor)
        self.renderer.AddActor2D(self.min_pt_text)
        self.renderer.AddActor2D(self.max_pt_text)
        self.render_window.Render()
```

--------------------------------

### Initialize PolygonExtrude

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/leaves.html

Create a default unit square extrusion or a custom extruded polygon from coplanar vertices.

```python
>>> from libvcad import pyvcad as pv
>>> poly = pv.PolygonExtrude()
```

```python
>>> from libvcad import pyvcad as pv
>>> verts = [pv.Vec3(0,0,0), pv.Vec3(10,0,0), pv.Vec3(10,10,0), pv.Vec3(0,10,0)]
>>> poly = pv.PolygonExtrude(verts, 5.0, False, 1)
```

--------------------------------

### Wizard Navigation Logic

Source: https://matterassembly.org/OpenVCAD-Docs/v2/_modules/pyvcad_rendering/export_frame.html

Handles page transitions for the back and next buttons, including conditional logic for compiler selection and export initiation.

```python
    def on_back(self, event):
        current_page = self.book.GetSelection()
        if current_page > 0:
            if current_page == 1: # From inputs to compiler selection
                self.open_folder_button.Hide()
            self.book.SetSelection(current_page - 1)
        self.update_buttons()

    def on_next(self, event):
        current_page = self.book.GetSelection()
        if current_page < self.book.GetPageCount() - 1:
            if current_page == 0: # From compiler selection to inputs
                self.update_compiler_input_panel()
                self.book.SetSelection(current_page + 1)
            elif current_page == 1: # From inputs to progress
                if self.start_export():
                    self.book.SetSelection(current_page + 1)
            else:
                self.book.SetSelection(current_page + 1)
        elif current_page == self.book.GetPageCount() - 1:
            # On the final confirmation page, close the app
            self.Close()
        self.update_buttons()
```

--------------------------------

### Prepare Node for Evaluation

Source: https://matterassembly.org/OpenVCAD-Docs/v2/python-api/pyvcad/tree.html

Executes initialization operations required before tree evaluation, such as setting voxel size and bandwidths.

```python
>>> from libvcad import pyvcad as pv
>>> sphere = pv.Sphere(pv.Vec3(0,0,0), 2, 2)
>>> sphere.prepare(pv.vec3(1, 1, 1), 0.1, 0.1)
```
Tokens:
Raw