Inviwo Tutorials: Getting Started

Main ideas and lessons (what the video teaches)

• Purpose of Inviwo’s GUI (getting started)

  • Learn the graphical user interface basics.
  • Become familiar enough to create workspaces using existing processors.

• Workspaces and the visualization pipeline

  • Inviwo visualizations are built as a network representing the steps of a visualization pipeline:
    • From importing data
    • To displaying results
  • The main network area is where this pipeline network is constructed.

• Processors as the core building blocks

  • Processors are the basic units of the network.
  • You select processors from the list on the left, then drag and drop them into the network editor.
  • A processor encapsulates one action, with adjustable properties.
  • Each processor has:
    • In-ports (inputs) and out-ports (outputs)
    • Shown as colored rectangles; the colors indicate data type.
  • Example described in the video:
    • Mesh Creator
      • Has a single out-port that outputs mesh data.
    • Canvas Processor
      • Takes the rendered image via its in-port.
    • Mesh Renderer
      • Converts mesh into something suitable to display (its rendered output connects to the canvas input).

• Connections and validation

  • After adding the needed processors and connections, the rendered result appears.
  • Green “lights” on processors indicate that the processors are working correctly.

• Inspecting the 3D view

  • You can inspect the mesh from different viewpoints:
    • Left mouse button: press and hold to look around (orbit/trackball intuition).
    • Other mouse buttons help understand navigation behavior.

• Ports: meaning and behavior

  • Port color = data type
    • Example given:
      • Yellow = meshes
      • Blue = images
  • Data flow direction
    • The network flows top to bottom.
    • In-ports are on top.
    • Out-ports are on bottom.
  • Optional ports
    • Some in-ports are marked optional with a small dot.
  • Quick port inspection
    • Hover over ports to preview contents and learn the data type.
    • Example hover info: a rendered image may come with additional outputs like a depth layer.

• Processor properties

  • Clicking/selecting a processor reveals its property list on the right.
  • Properties control processor settings (example given):
    • Changing light position
    • Changing light color (for the mesh renderer)

• Linking processors (synchronization)

  • When multiple processors have properties of the same type, Inviwo can automatically link them “to keep them in sync”.
  • Example use case:
    • Rendering two meshes separately while displaying them in the same canvas.
  • Linking behavior:
    • By default, synchronization happens in both directions.
    • You can change synchronization direction by clicking on the link.

• Writing output

  • The video mentions you can write the resulting image to a file.

• Performance / computation control

  • Normally, changing settings triggers automatic recomputation.
  • There is a button to switch off auto-compute behavior (useful when processing is heavy or data is large).

• Grouping processors to manage complexity

  • For large networks, processors can be grouped.
  • Grouping lets you abstract sub-networks into higher-level tasks.
  • Example idea: reduce a mesh rendering pipeline to “one processor each” by grouping internal steps.
  • Benefit: reduces complexity and makes large workspaces easier to manage.

• Concluding steps

  • Save the workspace and finish the tutorial.
  • Directs viewers to documentation and a Slack channel for further questions.

---

Methodology / workflow instructions (as presented)

Building a simple Inviwo workspace (from the GUI concepts described)

1. Start Inviwo:
   • Use the Getting Started page.
   • Note existing example workspaces; the tutorial creates a new workspace.
2. Build a visualization pipeline network:
   • In the main network editor area, add processors by:
     • Selecting processors from the left-side list
     • Dragging and dropping them into the network editor
3. Use the example pipeline described:
   • Add a Mesh Creator processor
   • Add a Mesh Renderer processor to turn mesh into rendered output
   • Add a Canvas processor to display the resulting image
4. Connect processors:
   • Create connections between out-ports and in-ports based on compatible data types (indicated by port colors).
5. Verify correctness:
   • Look for green lights on processors indicating they compute correctly.
6. Interact with output:
   • Use mouse controls to rotate/inspect the canvas view (trackball/orbit behavior).

Linking processors for synchronized behavior (two-mesh example)

1. Drag in additional processors (e.g., a second mesh pipeline).
2. Rely on Inviwo’s automatic linking when properties match in type (to keep settings synced, such as camera parameters).
3. If needed, adjust synchronization direction:
   • Click the link to change from bidirectional to one-directional syncing.

Handling heavy computations and large networks

• For performance
  • Use the button to disable automatic recompute when changes occur.
• For manageability
  • Group processors to encapsulate a complex sub-network into a higher-level unit.

Final steps

• Save the workspace.
• Use documentation / Slack if questions remain.

---

Speakers / sources featured

• Dominik — described as “core developer for Inviwo” (the presenter speaking in the video).