Vedo

https://vedo.embl.es/docs/
Admin
Vedo is a Python module for scientific analysis and visualization of 3D objects and point clouds...
Tokens:317,431
Snippets:1,394
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start Xvfb Display Server (Python)

Source: https://vedo.embl.es/docs/vedo/settings

Starts the X virtual framebuffer (Xvfb) service, which provides a virtual display for graphical applications without requiring a physical screen. It installs Xvfb if not present, sets the display environment variable, and launches Xvfb in the background. Includes a short delay to ensure the server is ready.

```python
@staticmethod
def start_xvfb() -> None:
    """
    Start xvfb.

    Xvfb or X virtual framebuffer is a display server implementing
    the X11 display server protocol. In contrast to other display servers,
    Xvfb performs all graphical operations in virtual memory
    without showing any screen output.
    """
    print("starting xvfb (can take a minute) ...", end="")
    res = os.system("which Xvfb")
    if res:
        os.system("apt-get install xvfb")
    os.system("set -x")
    os.system("export DISPLAY=:99.0")
    os.system("Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &")
    os.system("sleep 3")
    os.system("set +x")
    os.system('exec "$@"')
    print(" xvfb started.")
```

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

### Start Xvfb Display Server

Source: https://vedo.embl.es/docs/vedo/settings

Initializes the Xvfb (X virtual framebuffer) display server. This is crucial for running graphical applications in environments without a physical display. It checks for Xvfb, installs it if necessary, sets the display environment variable, and starts the virtual display server in the background.

```python
import os

def start_xvfb() -> None:
    """
    Start xvfb.

    Xvfb or X virtual framebuffer is a display server implementing
    the X11 display server protocol. In contrast to other display servers,
    Xvfb performs all graphical operations in virtual memory
    without showing any screen output.
    """
    print("starting xvfb (can take a minute) ...", end="")
    res = os.system("which Xvfb")
    if res:
        os.system("apt-get install xvfb")
    os.system("set -x")
    os.system("export DISPLAY=:99.0")
    os.system("Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &")
    os.system("sleep 3")
    os.system("set +x")
    os.system('exec "$@"')
    print(" xvfb started.")
```

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

### Install and Initialize pyvirtualdisplay and k3d

Source: https://vedo.embl.es/docs/vedo/settings

This snippet installs and initializes pyvirtualdisplay for virtual screen management and optionally k3d for 3D visualization in environments like Google Colab. It ensures necessary extensions are enabled and configures k3d for text protocol if installed.

```python
import os
from pyvirtualdisplay import Display
from google.colab import output

# Install xvfb if not present
os.system("apt-get install xvfb")

# Install pyvirtualdisplay
os.system("pip install pyvirtualdisplay")

# Start virtual display
Display(visible=0).start()

# Enable custom widget manager for Colab
output.enable_custom_widget_manager()

# Optional: Install and configure k3d
if enable_k3d:
    os.system("pip install k3d")
    import k3d
    try:
        print("installing k3d...", end="")
        os.system("jupyter nbextension install --py --user k3d")
        os.system("jupyter nbextension enable  --py --user k3d")
        k3d.switch_to_text_protocol()
        self.default_backend = "k3d"
        self.backend_autoclose = False
    except:
        print("(FAILED) ... ", end="")

print(" setup completed.")
```

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

### Initialize Colab Environment

Source: https://vedo.embl.es/docs/vedo/settings

Sets up the Google Colab environment, installing necessary packages like xvfb and pyvirtualdisplay. Optionally installs and configures k3d for 3D visualization and enables custom widget manager.

```python
def init_colab(self, enable_k3d=True) -> None:
        """
        Initialize colab environment
        """
        print("setting up colab environment (can take a minute) ...", end="")

        res = os.system("which Xvfb")
        if res:
            os.system("apt-get install xvfb")

        os.system("pip install pyvirtualdisplay")

        from pyvirtualdisplay import Display # type: ignore
        Display(visible=0).start()

        if enable_k3d:
            os.system("pip install k3d")

        from google.colab import output # type: ignore
        output.enable_custom_widget_manager()

        if enable_k3d:
            import k3d
            try:
                print("installing k3d...", end="")
                os.system("jupyter nbextension install --py --user k3d")
                os.system("jupyter nbextension enable  --py --user k3d")
                k3d.switch_to_text_protocol()
                self.default_backend = "k3d"
                self.backend_autoclose = False
            except:
                print("(FAILED) ... ", end="")

        print(" setup completed.")
```

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

### vedo bash aliases for examples and images

Source: https://vedo.embl.es/docs/vedo

Provides useful bash aliases for the vedo CLI to quickly search and run examples, search for strings within examples, and view images.

```bash
alias vr='vedo --run '	# to search and run examples by name
alias vs='vedo --search '	# to search for a string in examples
alias ve='vedo --eog '	# to view single and multiple images
```

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

### Initialize Colab Environment with k3d Support (Python)

Source: https://vedo.embl.es/docs/vedo/settings

Initializes the Google Colab environment, optionally installing and enabling the k3d backend for 3D visualizations. It sets up necessary packages like `pyvirtualdisplay` and `k3d`, configures virtual display, and enables custom widget manager for Colab. Handles potential installation failures gracefully.

```python
def init_colab(self, enable_k3d=True) -> None:
    """
    Initialize colab environment
    """
    print("setting up colab environment (can take a minute) ...", end="")

    res = os.system("which Xvfb")
    if res:
        os.system("apt-get install xvfb")

    os.system("pip install pyvirtualdisplay")

    from pyvirtualdisplay import Display # type: ignore
    Display(visible=0).start()

    if enable_k3d:
        os.system("pip install k3d")

    from google.colab import output # type: ignore
    output.enable_custom_widget_manager()

    if enable_k3d:
        import k3d
        try:
            print("installing k3d...", end="")
            os.system("jupyter nbextension install --py --user k3d")
            os.system("jupyter nbextension enable  --py --user k3d")
            k3d.switch_to_text_protocol()
            self.default_backend = "k3d"
            self.backend_autoclose = False
        except:
            print("(FAILED) ... ", end="")

    print(" setup completed.")
```

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

### Start Xvfb Display Server

Source: https://vedo.embl.es/docs/vedo/settings

Starts the Xvfb (X virtual framebuffer) display server. This is a virtual display server that performs graphical operations in memory without needing a physical screen, often used in headless environments.

```python
@staticmethod
    def start_xvfb() -> None:
        """
        Start xvfb.

        Xvfb or X virtual framebuffer is a display server implementing
        the X11 display server protocol. In contrast to other display servers,
        Xvfb performs all graphical operations in virtual memory
        without showing any screen output.
        """
        print("starting xvfb (can take a minute) ...", end="")
        res = os.system("which Xvfb")
        if res:
            os.system("apt-get install xvfb")
        os.system("set -x")
        os.system("export DISPLAY=:99.0")
```

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

### Start Xvfb virtual framebuffer

Source: https://vedo.embl.es/docs/vedo/settings

Starts an X virtual framebuffer to simulate a display environment. This is often used in headless environments or for running GUI applications that require a display server. It uses the `os.system` command to execute shell commands.

```python
os.system("Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &")
os.system("sleep 3")
os.system("set +x")
os.system('exec "$@"')
print(" xvfb started.")
```

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

### Plotter Initialization and Setup

Source: https://vedo.embl.es/docs/vedo/applications

Details on how to initialize the plotter, add actors, and configure axes.

```APIDOC
## Plotter Initialization and Setup

### Description
This section covers the initialization of the plotter, adding various actors like volumes and boxes, and configuring axes for visualization.

### Method
Initialization and Actor Addition

### Endpoint
N/A (Class methods and instance methods)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Example of plotter initialization and actor addition (conceptual)
plotter = VedoPlotter()
plotter.add_volume(my_volume)
plotter.add_box(my_box)
plotter.configure_axes()
```

### Response
#### Success Response (200)
Plotter object configured with specified actors and axes.

#### Response Example
```json
{
  "status": "success",
  "message": "Plotter initialized and configured."
}
```
```

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

### Install vedo and dependencies on Server (Bash)

Source: https://vedo.embl.es/docs/vedo

Installs the necessary 'libgl1-mesa' and 'xvfb' packages on a server, followed by the 'vedo' Python library using pip. This is a prerequisite for offscreen rendering.

```Bash
sudo apt install libgl1-mesa-glx libgl1-mesa-dev xvfb
pip install vedo
```

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

### Dockerfile for vedo Offscreen Rendering (Dockerfile)

Source: https://vedo.embl.es/docs/vedo

A Dockerfile that sets up a Python 3.8 environment with necessary libraries for offscreen rendering. It installs 'libgl1-mesa-dev', 'libgl1-mesa-glx', and 'xvfb', then installs 'vedo', and copies a startup script and Python test script into the container.

```Dockerfile
FROM python:3.8-slim-bullseye

RUN apt-get update -y \
  && apt-get install libgl1-mesa-dev libgl1-mesa-glx xvfb -y --no-install-recommends \
  && apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false \
  && rm -rf /var/lib/apt/lists/*
RUN pip install vedo && rm -rf $(pip cache dir)
RUN mkdir -p /app/data

WORKDIR /app/
COPY test.py set_xvfb.sh /app/
```

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

### vedo Command Line Interface examples

Source: https://vedo.embl.es/docs/vedo

Shows how to use the vedo command-line interface for general help and for opening a 3D model file directly from a URL.

```bash
vedo --help
vedo https://vedo.embl.es/examples/data/panther.stl.gz
```

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

### Draw Measurement Line in Python

Source: https://vedo.embl.es/docs/vedo/interactor_modes

Draws a line on the screen to represent a measurement. It captures the current event position as the end point and uses a predefined start point to draw the line. This function relies on the `draw_line` method and requires an active interactor to get event positions.

```python
def draw_measurement(self):
    """Draws a measurement line"""
    rwi = self.GetInteractor()
    self.end_x, self.end_y = rwi.GetEventPosition()
    self.draw_line(self.start_x, self.end_x, self.start_y, self.end_y)
```

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

### Draw Dragged Selection Rubber Band in Python

Source: https://vedo.embl.es/docs/vedo/interactor_modes

Draws a rubber band rectangle on the screen to indicate a selection area during a drag operation. It gets the current event position as the end point and uses stored start coordinates. This method depends on the `draw_rubber_band` function to render the visual selection.

```python
def draw_dragged_selection(self):
    """Draws the selection rubber band"""
    rwi = self.GetInteractor()
    self.end_x, self.end_y = rwi.GetEventPosition()
    self.draw_rubber_band(self.start_x, self.end_x, self.start_y, self.end_y)
```

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

### Install vedo using pip

Source: https://vedo.embl.es/docs/vedo

Installs the vedo Python package using pip. It can install the stable version or the latest development version from GitHub.

```bash
pip install vedo

# Or, install the latest development version with:
pip install -U git+https://github.com/marcomusy/vedo.git
```

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

### Get and Set Sigma in NonLinearTransform

Source: https://vedo.embl.es/docs/vedo/transformations

This code demonstrates how to get and set the sigma value for a NonLinearTransform. Sigma is a parameter that influences the transformation's behavior, often related to regularization or smoothness.

```python
@property
def sigma(self) -> float:
    """Set sigma."""
    return self.T.GetSigma()

@sigma.setter
def sigma(self, s):
    """Get sigma."""
    self.T.SetSigma(s)
```

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

### vedo Image FFT Example

Source: https://vedo.embl.es/docs/vedo/image

Demonstrates basic usage of vedo library for image manipulation, including loading, converting to grayscale, and displaying multiple versions of an image.

```python
from vedo import *
pic = Image(dataurl+'images/dog.jpg').bw()
show(pic, pic.clone().enhance(), N=2, mode='image', zoom='tight')
```

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

### Xvfb Startup Script for Docker (Bash)

Source: https://vedo.embl.es/docs/vedo

A bash script designed to be the entrypoint for a Docker container. It starts the Xvfb virtual display server, enabling offscreen rendering within the containerized environment.

```Bash
#!/bin/bash
set -x
export DISPLAY=:99.0
Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
#sleep 3
set +x
exec "$@"
```

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

### Basic vedo visualization example

Source: https://vedo.embl.es/docs/vedo

Demonstrates a simple vedo script to create a Cone, display it with axes, and then close the visualization window.

```python
import vedo
vedo.Cone().show(axes=1).close()
```

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

### Get Atom's Atomic Number (Python)

Source: https://vedo.embl.es/docs/vedo/chemistry

Retrieves the atomic number of a given atom. This method accesses the underlying VTK atom object to get its atomic number.

```python
def get_atomic_number(self):
        """Get the atomic number of the atom.

        Returns:
            The atomic number.
        """
        return self.vtk_atom.GetAtomicNumber()
```

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

### Initialize vedo Image from various sources

Source: https://vedo.embl.es/docs/vedo/image

Demonstrates how to instantiate the vedo Image class using different input types such as numpy arrays, vtkImageData objects, file paths (strings or PosixPath), and matplotlib figures. It handles image data loading and initial setup for rendering.

```python
from vedo import Image
import numpy as np
import vtk

# Example with numpy array
img_array = np.random.rand(100, 100, 3) * 255
image_from_array = Image(img_array)

# Example with vtkImageData
vtk_image_data = vtk.vtkImageData()
# ... set dimensions and scalar data for vtk_image_data ...
image_from_vtk = Image(vtk_image_data)

# Example with file path
# image_from_file = Image("path/to/your/image.png")

# Example with matplotlib figure
# import matplotlib.pyplot as plt
# fig, ax = plt.subplots()
# # ... draw on the figure ...
# image_from_fig = Image(fig)

```

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

### Enable vedo pipeline tracking

Source: https://vedo.embl.es/docs/vedo/settings

Describes how to enable tracking of the pipeline of actions that lead to a final object, allowing visualization of the object's construction via `myobj.pipeline.show()`.

```python
# Enable tracking pipeline functionality:
# allows to show a graph with the pipeline of action which let to a final object
# this is achieved by calling "myobj.pipeline.show()" (a new window will pop up)
settings.enable_pipeline = True
```

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

### Convert Line to Pixels (Python)

Source: https://vedo.embl.es/docs/vedo/interactor_modes

This function takes start and end coordinates (x1, y1) and (x2, y2) and returns lists of x and y pixel coordinates that form the line between these points. It handles cases where the start and end points are the same, returning a single point.

```python
def line2pixels(self, x1, x2, y1, y2):
        dx = x2 - x1
        dy = y2 - y1
        x = []
        y = []
        if abs(dx) >= abs(dy):
            r = range(0, dx, int(dx / abs(dx)))
            x = [x1 + i for i in r]
            y = [round(y1 + dy / dx * i) for i in r]
        else:
            r = range(0, dy, int(dy / abs(dy)))
            y = [y1 + i for i in r]
            x = [round(x1 + dx / dy * i) for i in r]

        return x, y
```

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

### Initialize and Use vedo Browser

Source: https://vedo.embl.es/docs/vedo/applications

Demonstrates how to load meshes and use the vedo Browser application to display them. It shows how to initialize the Browser with data, display it, and control playback. The `play` method is used to animate the sequence.

```python
from vedo import load, dataurl
from vedo.applications import Browser
meshes = load(dataurl+'timecourse1d.npy') # python list of Meshes
plt = Browser(meshes, bg='k')             # vedo.Plotter
plt.show(interactive=False, zoom='tight') # show the meshes
plt.play(dt=50)                           # delay in milliseconds
plt.close()
```

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

### TransformInterpolator Class Definition and Usage Example

Source: https://vedo.embl.es/docs/vedo/transformations

Defines the TransformInterpolator class for interpolating between linear transformations using either linear or spline methods. Includes an example demonstrating its usage by adding two transformations and then interpolating between them to visualize cubes at different positions and orientations.

```python
class TransformInterpolator:
    """
    Interpolate between a set of linear transformations.

    Position, scale and orientation (i.e., rotations) are interpolated separately,
    and can be interpolated linearly or with a spline function.
    Note that orientation is interpolated using quaternions via
    SLERP (spherical linear interpolation) or the special `vtkQuaternionSpline` class.

    To use this class, add at least two pairs of (t, transformation) with the add() method.
    Then interpolate the transforms with the `TransformInterpolator(t)` call method,
    where "t" must be in the range of `(min, max)` times specified by the add() method.

    Example:
        ```python
        from vedo import *

        T0 = LinearTransform()
        T1 = LinearTransform().rotate_x(90).shift([12,0,0])

        TRI = TransformInterpolator("linear")
        TRI.add(0, T0)
        TRI.add(1, T1)

        plt = Plotter(axes=1)
        for i in range(11):
            t = i/10
            T = TRI(t)
            plt += Cube().color(i).apply_transform(T)
        plt.show().close()
        ```
    """
    def __init__(self, mode="linear") -> None:
        """
        Interpolate between two or more linear transformations.
        """
        self.vtk_interpolator = vtki.new("TransformInterpolator")
        self.mode(mode)
        self.TS: List[LinearTransform] = []

    def __call__(self, t):
        """
        Get the intermediate transformation at time `t`.
        """
        xform = vtki.vtkTransform()
        self.vtk_interpolator.InterpolateTransform(t, xform)
        return LinearTransform(xform)

    def add(self, t, T) -> "TransformInterpolator":
        """Add intermediate transformations."""
        try:
            # in case a vedo object is passed
            T = T.transform
        except AttributeError:
            pass
        self.TS.append(T)
        self.vtk_interpolator.AddTransform(t, T.T)
        return self

    # def remove(self, t) -> "TransformInterpolator":
    #     """Remove intermediate transformations."""
    #     self.TS.pop(t)
    #     self.vtk_interpolator.RemoveTransform(t)
    #     return self

    def trange(self) -> np.ndarray:
        """Get interpolation range."""
        tmin = self.vtk_interpolator.GetMinimumT()
        tmax = self.vtk_interpolator.GetMaximumT()
        return np.array([tmin, tmax])

    def clear(self) -> "TransformInterpolator":
        """Clear all intermediate transformations."""
        self.TS = []
        self.vtk_interpolator.Initialize()
        return self

    def mode(self, m) -> "TransformInterpolator":
        """Set interpolation mode ('linear' or 'spline')."""
        if m == "linear":
            self.vtk_interpolator.SetInterpolationTypeToLinear()
        elif m == "spline":
            self.vtk_interpolator.SetInterpolationTypeToSpline()
        else:
            print('In TransformInterpolator mode can be either "linear" or "spline"')
        return self

    @property
    def ntransforms(self) -> int:
        """Get number of transformations."""
        return self.vtk_interpolator.GetNumberOfTransforms()
```

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

### Set up Vedo Logger and Stream Handler

Source: https://vedo.embl.es/docs/vedo

Initializes the 'vedo' logger, creates a StreamHandler, and configures it with custom formatting and a debug level. It also ensures standard output and error streams are handled, potentially redirecting null output.

```python
logger = logging.getLogger("vedo")

_chsh = logging.StreamHandler()
if sys.stdout is None:
    sys.stdout = open(os.devnull, "w")
if sys.stderr is None:
    sys.stderr = open(os.devnull, "w")
_chsh.flush = sys.stdout.flush
_chsh.setLevel(logging.DEBUG)
_chsh.setFormatter(_LoggingCustomFormatter())
logger.addHandler(_chsh)
logger.setLevel(logging.INFO)
```

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

### Get Object from Assembly (Python)

Source: https://vedo.embl.es/docs/vedo/assembly

Retrieves an object from the Assembly. It can accept an integer index to get the i-th object, or a string to find the first object whose name contains the given string. If no object is found or the input is invalid, an empty list is returned.

```python
def __getitem__(self, i):
        """Get i-th object from an Assembly.
        Input can be a string, in this case returns the first object
        whose name contains the given string.

        Examples:
            - [custom_axes4.py](https://github.com/marcomusy/vedo/tree/master/examples/pyplot/custom_axes4.py)
        """
        if i is None:
            return self.objects
        elif isinstance(i, int):
            return self.objects[i]
        elif isinstance(i, str):
            for m in self.objects:
                if i == m.name:
                    return m
        return []
```

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

### Get Position

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current position of the object.

```APIDOC
## GET /position

### Description
Computes and returns the current position of the object.

### Method
GET

### Endpoint
/position

### Response
#### Success Response (200)
- **position** (list[float]) - A list of three floats representing the position [x, y, z].

#### Response Example
```json
{
  "position": [10, 20, 30]
}
```
```

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

### Enable Vedo Pipeline Tracking

Source: https://vedo.embl.es/docs/vedo/settings

Enables the tracking of the visualization pipeline, allowing users to visualize the sequence of operations that lead to a final object by calling `myobj.pipeline.show()`. This opens a new window displaying the pipeline graph.

```python
# Enable tracking pipeline functionality:
# allows to show a graph with the pipeline of action which let to a final object
# this is achieved by calling "myobj.pipeline.show()" (a new window will pop up)
self.enable_pipeline = True
```

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

### Initialize Video Object (Python)

Source: https://vedo.embl.es/docs/vedo/file_io

Initializes a Video object for video creation. It sets up parameters like filename, duration, frames per second, and the backend to be used. It also prepares a temporary directory for storing frames.

```python
self.name = str(name)
self.duration = duration
self.backend = backend
self.fps = float(fps)
self.command = "ffmpeg -loglevel panic -y -r"
self.options = "-b:v 8000k"
self.scale = scale

self.frames = []
self.tmp_dir = TemporaryDirectory()
self.get_filename = lambda x: os.path.join(self.tmp_dir.name, x)
colors.printc(":video:  Video file", self.name, "is open... ", c="m", end="")
```

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

### Get Orientation

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current orientation of the object.

```APIDOC
## GET /orientation

### Description
Computes and returns the current orientation of the object.

### Method
GET

### Endpoint
/orientation

### Response
#### Success Response (200)
- **orientation** (list[float]) - A list of three floats representing the orientation [x, y, z] in degrees.

#### Response Example
```json
{
  "orientation": [0, 0, 90]
}
```
```

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

### Initialize NonLinearTransform with various inputs

Source: https://vedo.embl.es/docs/vedo/transformations

Demonstrates how to initialize the NonLinearTransform class with different types of inputs, including VTK transformation objects, filenames, dictionaries, and keyword arguments. It also shows how to set source and target points, mode (2D/3D), and sigma for the transformation.

```python
from vedo import *
settings.use_parallel_projection = True

NLT = NonLinearTransform()
source_points = [[-2,0,0], [1,2,1], [2,-2,2]]
target_points = NLT.source_points + np.random.randn(3,3)*0.5
NLT.source_points = source_points
NLT.target_points = target_points
NLT.mode = '3d'
print(NLT)

s1 = Sphere()
NLT.move(s1)

arrs = Arrows(NLT.source_points, NLT.target_points)
show(s1, arrs, Sphere().alpha(0.1), axes=1).close()
```

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

### Get Position

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current position of the object.

```APIDOC
## GET /position

### Description
Retrieves the current spatial coordinates [x, y, z] of the object's origin.

### Method
GET

### Endpoint
/position

### Response
#### Success Response (200)
- **position** (np.ndarray) - A numpy array containing the [x, y, z] coordinates.

#### Response Example
```json
{
  "position": [0.0, 0.0, 0.0]
}
```
```

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

### Get Orientation

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current orientation of the object.

```APIDOC
## GET /orientation

### Description
Retrieves the current orientation of the object, typically represented as Euler angles (e.g., roll, pitch, yaw).

### Method
GET

### Endpoint
/orientation

### Response
#### Success Response (200)
- **orientation** (np.ndarray) - A numpy array representing the object's orientation.

#### Response Example
```json
{
  "orientation": [0.0, 0.0, 0.0]
}
```
```

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

### Vedo Global Variables and Path Configuration

Source: https://vedo.embl.es/docs/vedo

This section initializes global variables for the vedo library, including author, license, and website information. It also determines the VTK version, sets the installation directory, defines a data URL, and configures font paths. It includes logic to handle cases where the default font path might not exist.

```python
######################################################################### GLOBALS
__author__     = "Marco Musy"
__license__    = "MIT"
__maintainer__ = "M. Musy"
__email__      = "marco.musy@embl.es"
__website__    = "https://github.com/marcomusy/vedo"


##########################################################################
vtk_version = (
    int(vtkVersion().GetVTKMajorVersion()),
    int(vtkVersion().GetVTKMinorVersion()),
    int(vtkVersion().GetVTKBuildVersion()),
)

installdir = os.path.dirname(__file__)
dataurl = "https://vedo.embl.es/examples/data/"

plotter_instance = None
notebook_plotter = None
notebook_backend = None

## fonts
fonts_path = os.path.join(installdir, "fonts/")

# Note:
# a fatal error occurs when compiling to exe,
# developer needs to copy the fonts folder to the same location as the exe file
# to solve this problem
if not os.path.exists(fonts_path):
    fonts_path = "fonts/"

fonts = [_f.split(".")[0] for _f in os.listdir(fonts_path) if '.npz' not in _f]
fonts = list(sorted(fonts))

# pyplot module to remember last figure format
last_figure = None

```

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

### Get Scale

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current scale of the object.

```APIDOC
## GET /get_scale

### Description
Retrieves the current scale factors applied to the object along the x, y, and z axes.

### Method
GET

### Endpoint
/get_scale

### Response
#### Success Response (200)
- **scale** (np.ndarray) - A numpy array containing the [x, y, z] scale factors.

#### Response Example
```json
{
  "scale": [1.0, 1.0, 1.0]
}
```
```

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

### Python: Ask command-line question with options

Source: https://vedo.embl.es/docs/vedo/file_io

The `ask` function prompts the user with a question and optionally provides a list of choices. It handles default responses and validates user input against the provided options. It leverages `colors.printc` for formatted output.

```python
def ask(*question, **kwarg) -> str:
    """
    Ask a question from command line. Return the answer as a string.
    See function `colors.printc()` for the description of the keyword options.

    Arguments:
        options : (list)
            a python list of possible answers to choose from.
        default : (str)
            the default answer when just hitting return.

    Example:
    ```python
    import vedo
    res = vedo.ask("Continue?", options=['Y','n'], default='Y', c='g')
    print(res)
    ```
    """
    kwarg.update({"end": " "})
    if "invert" not in kwarg:
        kwarg.update({"invert": True})
    if "box" in kwarg:
        kwarg.update({"box": ""})

    options = kwarg.pop("options", [])
    default = kwarg.pop("default", "")
    if options:
        opt = "["
        for o in options:
            opt += o + "/"
        opt = opt[:-1] + "]"
        colors.printc(*question, opt, **kwarg)
    else:
        colors.printc(*question, **kwarg)

    try:
        resp = input()
    except Exception:
        resp = ""
        return resp

    if options:
        if resp not in options:
            if default and str(repr(resp)) == "''":
                return default
            colors.printc("Please choose one option in:", opt, italic=True, bold=False)
            kwarg["options"] = options
            return ask(*question, **kwarg)  # ask again
    return resp
```

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

### GET /websites/vedo_embl_es/mesh/get_concatenated_transform

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves an intermediate matrix by its concatenation index.

```APIDOC
## GET /websites/vedo_embl_es/mesh/get_concatenated_transform

### Description
Get intermediate matrix by concatenation index.

### Method
GET

### Endpoint
/websites/vedo_embl_es/mesh/get_concatenated_transform

### Parameters
#### Query Parameters
- **i** (int) - Required - The index of the transformation matrix to retrieve.

### Response
#### Success Response (200)
- **LinearTransform** - The intermediate transformation matrix.

#### Response Example
```json
{
  "transform": "[matrix data]"
}
```
```

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

### Initialize default configuration settings

Source: https://vedo.embl.es/docs/vedo/settings

Initializes the default backend and font settings. Detects if running in a Jupyter environment to set the backend to '2d' if applicable.

```python
self.default_backend = "vtk"
try:
    shell = get_ipython().__class__.__name__ # type: ignore
    if shell == 'ZMQInteractiveShell':
        self.default_backend = "2d"
except NameError:
    pass

self.default_font = "Normografo"
```

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

### vedo.show() - Window and Background Properties

Source: https://vedo.embl.es/docs/vedo/applications

Set the position, size, title, and background properties of the rendering window.

```APIDOC
## vedo.show()

### Description
Sets window properties such as position, size, title, and background colors or images.

### Method
show()

### Parameters
#### Arguments
- **pos** (list) - (x,y) position in pixels of top-left corner of the rendering window on the screen.
- **size** (str, list) - Size of the rendering window. If 'auto', guess it based on screensize.
- **screensize** (list) - Physical size of the monitor screen in pixels.
- **bg** (color, str) - Background color or specify jpg image file name with path.
- **bg2** (color) - Background color of a gradient towards the top.
- **title** (str) - Window title.
```

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

### Get Matrix

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the 4x4 transformation matrix of the object.

```APIDOC
## GET /matrix

### Description
Retrieves the current 4x4 transformation matrix that represents the object's position, rotation, and scale.

### Method
GET

### Endpoint
/matrix

### Response
#### Success Response (200)
- **matrix** (np.ndarray) - A 4x4 numpy array representing the transformation matrix.

#### Response Example
```json
{
  "matrix": [
    [1.0, 0.0, 0.0, 0.0],
    [0.0, 1.0, 0.0, 0.0],
    [0.0, 0.0, 1.0, 0.0],
    [0.0, 0.0, 0.0, 1.0]
  ]
}
```
```

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

### Initialize vedo Settings and Detect Backend

Source: https://vedo.embl.es/docs/vedo/settings

Initializes the Settings object for the vedo library. It attempts to detect if the code is running within a Jupyter Notebook environment (specifically ZMQInteractiveShell) and sets the default backend to '2d' if detected; otherwise, it defaults to 'vtk'.

```python
import os
from vedo.settings import Settings

class Settings:
    def __init__(self) -> None:
        self.default_backend = "vtk"
        try:
            # adapted from: https://stackoverflow.com/a/39662359/2912349
            shell = get_ipython().__class__.__name__ # type: ignore
            if shell == 'ZMQInteractiveShell':
                self.default_backend = "2d"
        except NameError:
            pass

        self.default_font = "Normografo"
        # ... other settings ...

        # check if environment variable VEDO_CACHE_DIR is set
        if "VEDO_CACHE_DIR" in os.environ:
            self.cache_directory = os.environ["VEDO_CACHE_DIR"]
        else:
            self.cache_directory = ".cache"  # "/vedo" is appended automatically
        # ... rest of the __init__ method ...

```

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

### Interpolate Transform

Source: https://vedo.embl.es/docs/vedo/transformations

Gets the intermediate transformation at a given time t.

```APIDOC
## Interpolate Transform

### Description
Retrieves the interpolated `LinearTransform` at a specified time `t`.

### Method
```python
__call__(self, t)
```

### Parameters
- **t** (float) - Required - The time point for which to interpolate the transformation. Must be within the range of times added using `add()`.

### Returns
- **LinearTransform** - The interpolated transformation at time `t`.
```

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

### Initialize Colab Environment in Python

Source: https://vedo.embl.es/docs/vedo/settings

This Python method initializes the Colab environment, optionally enabling k3d. It checks for the presence of 'Xvfb' using `os.system`.

```Python
import os
def init_colab(self, enable_k3d=True) -> None:
    """
    Initialize colab environment
    """
    print("setting up colab environment (can take a minute) ...", end="")

    res = os.system("which Xvfb")
```

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

### LinearTransform Number of Transforms

Source: https://vedo.embl.es/docs/vedo/transformations

Gets the total count of transformations that have been concatenated.

```APIDOC
## ntransforms

### Description
Get the number of concatenated transforms.

### Method
`ntransforms` (property)

### Endpoint
N/A (Class Property)

### Parameters
None

### Response
- `int` - The total number of concatenated transformations.
```

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

### Generate Documentation with pdoc

Source: https://vedo.embl.es/docs/vedo

This snippet shows how to generate documentation using the pdoc tool. It involves navigating to a specific directory and executing a Python script. This is typically used in a development or build process to create project documentation.

```bash
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
##### To generate documentation
# cd ~/Projects/vedo/docs/pdoc
# ./build_html.py
###############################

```

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

### Render Video using FFmpeg Backend

Source: https://vedo.embl.es/docs/vedo/file_io

Renders a video using the FFmpeg backend by constructing and executing a system command. It requires FFmpeg to be installed and accessible in the system's PATH. The command takes the FPS, temporary directory containing frames, and output filename as arguments.

```python
if self.backend == "ffmpeg":
            out = os.system(
                self.command
                + " "
                + str(self.fps)
                + " -i "
                + f"'{self.tmp_dir.name}'"
                + os.sep
                + "%01d.png "
                + self.options
                + " "
                + f"'{self.name}'"
            )
            if out:
                vedo.logger.error(f":noentry: backend {self.backend} returning error: {out}")
            else:
                colors.printc(f":save: saved to {self.name}", c="m")
```

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

### Get Number of Transformations

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the count of transformations currently added to the interpolator.

```APIDOC
## Get Number of Transformations

### Description
Returns the total number of transformations that have been added to the interpolator.

### Method
```python
@property
get_ntransforms(self)
```

### Returns
- **int** - The number of transformations.
```

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

### Get Interpolation Range

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the minimum and maximum time points for the interpolation.

```APIDOC
## Get Interpolation Range

### Description
Returns the minimum and maximum time points that have been added to the interpolator.

### Method
```python
trange(self)
```

### Returns
- **np.ndarray** - A numpy array containing the minimum and maximum time points [tmin, tmax].
```

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

### Ask User Input with Options and Default Value (Python)

Source: https://vedo.embl.es/docs/vedo/file_io

Demonstrates how to use the `ask` function to prompt the user for input. It accepts a list of options to choose from and a default value that is used if the user simply presses return. The result of the user's choice is printed.

```python
import vedo
res = ask("Continue?", options=['Y','n'], default='Y', c='g')
print(res)
```

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

### GET /websites/vedo_embl_es/mesh/ntransforms

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the total number of concatenated transformations applied to the mesh.

```APIDOC
## GET /websites/vedo_embl_es/mesh/ntransforms

### Description
Get the number of concatenated transforms.

### Method
GET

### Endpoint
/websites/vedo_embl_es/mesh/ntransforms

### Parameters
No parameters required.

### Response
#### Success Response (200)
- **int** - The number of concatenated transforms.

#### Response Example
```json
{
  "count": 5
}
```
```

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

### Vedo Library Imports and Initialization

Source: https://vedo.embl.es/docs/vedo

This Python code block imports essential modules for the vedo visualization library. It includes standard libraries like `os`, `sys`, `logging`, and `numpy`, as well as specific VTK modules and various components of the vedo library itself. It also includes error handling for VTK installation and checks the system platform.

```python
import os
import sys
import logging
import numpy as np
from numpy import sin, cos, sqrt, exp, log, dot, cross  # just because handy

try:
    from vtkmodules.vtkCommonCore import vtkVersion
except ModuleNotFoundError:
    print("Cannot find VTK installation. Please install it with:")
    print("pip install vtk")
    sys.exit(1)

#################################################
from vedo.version import _version as __version__

from vedo.settings import Settings
settings = Settings()

from vedo.colors import *
from vedo.transformations import *
from vedo.utils import *
from vedo.core import *
from vedo.shapes import *
from vedo.file_io import *
from vedo.assembly import *
from vedo.pointcloud import *
from vedo.mesh import *
from vedo.image import *
from vedo.volume import *
from vedo.grids import *
from vedo.addons import *
from vedo.plotter import *
from vedo.visual import *

from vedo import applications
from vedo import interactor_modes

try:
    import platform
    sys_platform = platform.system()
except (ModuleNotFoundError, AttributeError) as e:
    sys_platform = ""

```

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

### Get Matrix 3x3

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the 3x3 rotation/scale part of the transformation matrix.

```APIDOC
## GET /matrix3x3

### Description
Retrieves the 3x3 part of the transformation matrix, which typically represents rotation and scaling, excluding translation.

### Method
GET

### Endpoint
/matrix3x3

### Response
#### Success Response (200)
- **matrix3x3** (np.ndarray) - A 3x3 numpy array representing the rotation and scale components of the transformation.

#### Response Example
```json
{
  "matrix3x3": [
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0]
  ]
}
```
```

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

### Get NonLinearTransform sigma value

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current sigma value used by the NonLinearTransform.

```python
@property
    def sigma(self) -> float:
        """Set sigma."""
        return self.T.GetSigma()
```

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

### Convert file format using vedo CLI

Source: https://vedo.embl.es/docs/vedo

Demonstrates how to use the vedo command-line tool to convert a 3D file from one format to another on the fly.

```bash
vedo --convert bunny.obj --to ply
```

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

### Basic vedo visualization in Google Colab

Source: https://vedo.embl.es/docs/vedo

A simple example demonstrating how to create and display a Sphere using vedo in a Google Colab notebook after initialization.

```python
import vedo
print("vedo", vedo.__version__)
sphere = vedo.Sphere().linewidth(1)
plt = vedo.Plotter()
plt += sphere
plt.show(axes=1, viewup='z', zoom=1.5)
```

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

### Get Scale

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves the current scale factors applied to the object along each axis.

```APIDOC
## GET /get_scale

### Description
Gets the current scale of the object.

### Method
GET

### Endpoint
/get_scale

### Response
#### Success Response (200)
- **scale** (list[float]) - A list of three floats representing the scale factors [x, y, z].

#### Response Example
```json
{
  "scale": [1.5, 1.0, 1.0]
}
```
```

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

### LinearTransform Get Concatenated Transform

Source: https://vedo.embl.es/docs/vedo/transformations

Retrieves an intermediate transformation matrix from a series of concatenations.

```APIDOC
## get_concatenated_transform(i)

### Description
Get an intermediate matrix by its concatenation index.

### Method
`get_concatenated_transform(i)`

### Endpoint
N/A (Class Method)

### Parameters
- **i** (int) - The index of the concatenated transformation to retrieve.

### Response
- `LinearTransform` - The LinearTransform object corresponding to the specified concatenation index.
```

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

### Configure vedo material and lighting

Source: https://vedo.embl.es/docs/vedo/settings

Details settings for material properties like point, line, and polygon smoothing, as well as lighting behavior including camera-following lights and two-sided lighting.

```python
# Smoothing options for points, lines and polygons
settings.point_smoothing = False
settings.line_smoothing = False
settings.polygon_smoothing = False

# Turn on/off the automatic repositioning of lights as the camera moves
settings.light_follows_camera = False
settings.two_sided_lighting = True
```
Tokens:
Raw