vedo.file_io

Submodule to read/write meshes and other objects in different formats, and other I/O functionalities.

View Source

   1import glob
   2import os
   3import time
   4from tempfile import NamedTemporaryFile, TemporaryDirectory
   5from typing import Any, List, Tuple, Union
   6
   7import numpy as np
   8
   9import vedo.vtkclasses as vtki  # a wrapper for lazy imports
  10
  11import vedo
  12from vedo import settings
  13from vedo import colors
  14from vedo import utils
  15from vedo.assembly import Assembly
  16from vedo.image import Image
  17from vedo.pointcloud import Points
  18from vedo.mesh import Mesh
  19from vedo.volume import Volume
  20
  21__docformat__ = "google"
  22
  23__doc__ = """
  24Submodule to read/write meshes and other objects in different formats,
  25and other I/O functionalities.
  26"""
  27
  28__all__ = [
  29    "load",
  30    "read",
  31    "download",
  32    "gunzip",
  33    "loadStructuredPoints",
  34    "loadStructuredGrid",
  35    "write",
  36    "save",
  37    "export_window",
  38    "import_window",
  39    "load_obj",
  40    "screenshot",
  41    "ask",
  42    "Video",
  43]
  44
  45
  46# example web page for X3D
  47_x3d_html_template = """
  48<!DOCTYPE html>
  49<html lang="en">
  50<head>
  51  <meta charset="UTF-8">
  52  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  53  <title> vedo with x3d </title>
  54
  55  <!-- THESE ARE THE RELEVANT LINES: -->
  56  <script src='https://www.x3dom.org/download/x3dom.js'> </script>
  57  <link rel='stylesheet' type='text/css' href='https://www.x3dom.org/download/x3dom.css'/>
  58
  59  <style>
  60     table, td, th { border: 1px solid black; background-color: powderblue;}
  61     table {width: 70%; border-collapse: collapse;}
  62     table th {width: 35%;}
  63  </style>
  64</head>
  65
  66<body style="font-family: Verdana">
  67  <h1>Example html generated by vedo</h1>
  68  This example loads a 3D scene from file ~fileoutput generated by
  69  <a href="https://github.com/marcomusy/vedo">vedo</a>
  70  (see <a href="https://github.com/marcomusy/vedo/tree/master/examples/other/export_x3d.py">export_x3d.py</a>).
  71  <br><br>
  72
  73
  74  <!-- THESE ARE THE RELEVANT LINES: -->
  75  <x3d width='~widthpx' height='~heightpx'>
  76     <scene>
  77        <Inline url="~fileoutput"> </Inline>
  78     </scene>
  79  </x3d>
  80
  81  <h3>Nothing shows up above this line?</h3>
  82  Enable your browser to load local files:
  83  <br><b>Firefox</b>: type <code>about:config</code> in the URL bar and
  84  change <code>privacy.file_unique_origin</code> from <code>True</code> to <code>False</code>
  85  <br><b>Chrome</b>: from terminal type:
  86  <code>google-chrome --enable-webgl --allow-file-access-from-files</code>
  87  (see <a href="https://cmatskas.com/interacting-with-local-data-files-using-chrome/">here</a>)
  88
  89  <br>
  90  <h3>Controls:</h3>
  91  <h4><strong>Examine Mode (activate with key 'e'):</strong></h4>
  92  <table>
  93     <tbody>
  94        <tr class="even description">
  95           <th>Button</th>
  96           <th>Function</th>
  97        </tr>
  98        <tr>
  99           <td>Left Button / Left Button + Shift</td>
 100           <td>Rotate</td>
 101        </tr>
 102        <tr>
 103           <td>Mid Button / Left Button + Ctl</td>
 104           <td>Pan</td>
 105        </tr>
 106        <tr>
 107           <td>Right Button / Wheel / Left Button + Alt</td>
 108           <td>Zoom</td>
 109        </tr>
 110        <tr>
 111           <td>Left double click</td>
 112           <td>Set center of rotation</td>
 113        </tr>
 114     </tbody>
 115  </table>
 116  <h4><strong>Walk Mode (activate with key 'w'):</strong></h4>
 117  <table>
 118     <tbody>
 119        <tr class="even description">
 120           <th>Button</th>
 121           <th>Function</th>
 122        </tr>
 123        <tr>
 124           <td>Left Button</td>
 125           <td>Move forward</td>
 126        </tr>
 127        <tr>
 128           <td>Right Button</td>
 129           <td>Move backward</td>
 130        </tr>
 131     </tbody>
 132  </table>
 133  <h4><strong>Fly Mode (activate with key 'f'):</strong></h4>
 134  <table>
 135     <tbody>
 136        <tr class="even description">
 137           <th>Button</th>
 138           <th>Function</th>
 139        </tr>
 140        <tr>
 141           <td>Left Button</td>
 142           <td>Move forward</td>
 143        </tr>
 144        <tr>
 145           <td>Right Button</td>
 146           <td>Move backward</td>
 147        </tr>
 148     </tbody>
 149  </table>
 150  <h3>Non-interactive camera movement</h3>
 151  <table>
 152     <tbody>
 153        <tr class="even description">
 154           <th>Key</th>
 155           <th>Function</th>
 156        </tr>
 157        <tr>
 158           <td>r</td>
 159           <td>reset view</td>
 160        </tr>
 161        <tr>
 162           <td>a</td>
 163           <td>show all</td>
 164        </tr>
 165        <tr>
 166           <td>u</td>
 167           <td>upright</td>
 168        </tr>
 169     </tbody>
 170  </table>
 171</body>
 172</html>
 173"""
 174
 175########################################################################
 176def load(inputobj: Union[list, str, os.PathLike], unpack=True, force=False) -> Any:
 177    """
 178    Load any vedo objects from file or from the web.
 179
 180    The output will depend on the file extension. See examples below.
 181    Unzip is made on the fly, if file ends with `.gz`.
 182    Can load an object directly from a URL address.
 183
 184    Arguments:
 185        unpack : (bool)
 186            unpack MultiBlockData into a flat list of objects.
 187        force : (bool)
 188            when downloading a file ignore any previous cached downloads and force a new one.
 189
 190    Example:
 191        ```python
 192        from vedo import dataurl, load, show
 193        # Return a list of 2 meshes
 194        g = load([dataurl+'250.vtk', dataurl+'270.vtk'])
 195        show(g)
 196        # Return a list of meshes by reading all files in a directory
 197        # (if directory contains DICOM files then a Volume is returned)
 198        g = load('mydicomdir/')
 199        show(g)
 200        ```
 201    """
 202    if isinstance(inputobj, list):
 203        inputobj = [str(f) for f in inputobj]
 204    else:
 205        inputobj = str(inputobj)
 206    
 207    acts = []
 208    if utils.is_sequence(inputobj):
 209        flist = inputobj
 210    elif isinstance(inputobj, str) and inputobj.startswith("https://"):
 211        flist = [inputobj]
 212    else:
 213        flist = utils.humansort(glob.glob(inputobj))
 214
 215    for fod in flist:
 216
 217        if fod.startswith("https://"):
 218            fod = download(fod, force=force, verbose=False)
 219
 220        if os.path.isfile(fod):  ### it's a file
 221
 222            if fod.endswith(".gz"):
 223                fod = gunzip(fod)
 224
 225            a = _load_file(fod, unpack)
 226            acts.append(a)
 227
 228        elif os.path.isdir(fod):  ### it's a directory or DICOM
 229            flist = os.listdir(fod)
 230            if ".dcm" in flist[0]:  ### it's DICOM
 231                reader = vtki.new("DICOMImageReader")
 232                reader.SetDirectoryName(fod)
 233                reader.Update()
 234                image = reader.GetOutput()
 235                vol = Volume(image)
 236                try:
 237                    vol.metadata["PixelSpacing"] = reader.GetPixelSpacing()
 238                    vol.metadata["Width"] = reader.GetWidth()
 239                    vol.metadata["Height"] = reader.GetHeight()
 240                    vol.metadata["PositionPatient"] = reader.GetImagePositionPatient()
 241                    vol.metadata["OrientationPatient"] = reader.GetImageOrientationPatient()
 242                    vol.metadata["BitsAllocated"] = reader.GetBitsAllocated()
 243                    vol.metadata["PixelRepresentation"] = reader.GetPixelRepresentation()
 244                    vol.metadata["NumberOfComponents"] = reader.GetNumberOfComponents()
 245                    vol.metadata["TransferSyntaxUID"] = reader.GetTransferSyntaxUID()
 246                    vol.metadata["RescaleSlope"] = reader.GetRescaleSlope()
 247                    vol.metadata["RescaleOffset"] = reader.GetRescaleOffset()
 248                    vol.metadata["PatientName"] = reader.GetPatientName()
 249                    vol.metadata["StudyUID"] = reader.GetStudyUID()
 250                    vol.metadata["StudyID"] = reader.GetStudyID()
 251                    vol.metadata["GantryAngle"] = reader.GetGantryAngle()
 252                except Exception as e:
 253                    vedo.logger.warning(f"Cannot read DICOM metadata: {e}")
 254                acts.append(vol)
 255
 256            else:  ### it's a normal directory
 257                utils.humansort(flist)
 258                for ifile in flist:
 259                    a = _load_file(fod + "/" + ifile, unpack)
 260                    acts.append(a)
 261        else:
 262            vedo.logger.error(f"in load(), cannot find {fod}")
 263
 264    if len(acts) == 1:
 265        if "numpy" in str(type(acts[0])):
 266            return acts[0]
 267        if not acts[0]:
 268            vedo.logger.error(f"in load(), cannot load {inputobj}")
 269        return acts[0]
 270
 271    if len(acts) == 0:
 272        vedo.logger.error(f"in load(), cannot load {inputobj}")
 273        return None
 274
 275    else:
 276        return acts
 277
 278########################################################################
 279def _load_file(filename, unpack):
 280    fl = filename.lower()
 281
 282    ########################################################## other formats:
 283    if fl.endswith(".xml") or fl.endswith(".xml.gz") or fl.endswith(".xdmf"):
 284        # Fenics tetrahedral file
 285        objt = loadDolfin(filename)
 286    elif fl.endswith(".neutral") or fl.endswith(".neu"):  # neutral tets
 287        objt = loadNeutral(filename)
 288    elif fl.endswith(".gmsh"):  # gmesh file
 289        objt = loadGmesh(filename)
 290    elif fl.endswith(".pcd"):  # PCL point-cloud format
 291        objt = loadPCD(filename)
 292        objt.properties.SetPointSize(2)
 293    elif fl.endswith(".off"):
 294        objt = loadOFF(filename)
 295    elif fl.endswith(".3ds"):  # 3ds format
 296        objt = load3DS(filename)
 297    elif fl.endswith(".wrl"):
 298        importer = vtki.new("VRMLImporter")
 299        importer.SetFileName(filename)
 300        importer.Read()
 301        importer.Update()
 302        actors = importer.GetRenderer().GetActors()  # vtkActorCollection
 303        actors.InitTraversal()
 304        wacts = []
 305        for i in range(actors.GetNumberOfItems()):
 306            act = actors.GetNextActor()
 307            m = Mesh(act.GetMapper().GetInput())
 308            m.actor = act
 309            wacts.append(m)
 310        objt = Assembly(wacts)
 311
 312    ######################################################## volumetric:
 313    elif (
 314        fl.endswith(".tif")
 315        or fl.endswith(".tiff")
 316        or fl.endswith(".slc")
 317        or fl.endswith(".vti")
 318        or fl.endswith(".mhd")
 319        or fl.endswith(".nrrd")
 320        or fl.endswith(".nii")
 321        or fl.endswith(".dem")
 322    ):
 323        img = loadImageData(filename)
 324        objt = Volume(img)
 325
 326    ######################################################### 2D images:
 327    elif (
 328        fl.endswith(".png")
 329        or fl.endswith(".jpg")
 330        or fl.endswith(".bmp")
 331        or fl.endswith(".jpeg")
 332        or fl.endswith(".gif")
 333    ):
 334        if ".png" in fl:
 335            picr = vtki.new("PNGReader")
 336        elif ".jpg" in fl or ".jpeg" in fl:
 337            picr = vtki.new("JPEGReader")
 338        elif ".bmp" in fl:
 339            picr = vtki.new("BMPReader")
 340        elif ".gif" in fl:
 341            from PIL import Image as PILImage, ImageSequence
 342
 343            img = PILImage.open(filename)
 344            frames = []
 345            for frame in ImageSequence.Iterator(img):
 346                a = np.array(frame.convert("RGB").getdata(), dtype=np.uint8)
 347                a = a.reshape([frame.size[1], frame.size[0], 3])
 348                frames.append(Image(a))
 349            return frames
 350
 351        picr.SetFileName(filename)
 352        picr.Update()
 353        objt = Image(picr.GetOutput())
 354
 355    ######################################################### multiblock:
 356    elif fl.endswith(".vtm") or fl.endswith(".vtmb"):
 357        read = vtki.new("XMLMultiBlockDataReader")
 358        read.SetFileName(filename)
 359        read.Update()
 360        mb = read.GetOutput()
 361        if unpack:
 362            acts = []
 363            for i in range(mb.GetNumberOfBlocks()):
 364                b = mb.GetBlock(i)
 365                if isinstance(
 366                    b,
 367                    (
 368                        vtki.vtkPolyData,
 369                        vtki.vtkStructuredGrid,
 370                        vtki.vtkRectilinearGrid,
 371                    ),
 372                ):
 373                    acts.append(Mesh(b))
 374                elif isinstance(b, vtki.vtkImageData):
 375                    acts.append(Volume(b))
 376                elif isinstance(b, vtki.vtkUnstructuredGrid):
 377                    acts.append(vedo.UnstructuredGrid(b))
 378            return acts
 379        return mb
 380    
 381    ######################################################### assembly:
 382    elif fl.endswith(".npy"):
 383        data = np.load(filename, allow_pickle=True)
 384        try:
 385            # old format with a single object
 386            meshs = [from_numpy(dd) for dd in data]
 387        except TypeError:
 388            data = data.item()
 389            meshs = []
 390            for ad in data["objects"][0]["parts"]:
 391                obb = from_numpy(ad)
 392                meshs.append(obb)
 393        return Assembly(meshs)
 394
 395    ###########################################################
 396    elif fl.endswith(".geojson"):
 397        return loadGeoJSON(filename)
 398
 399    elif fl.endswith(".pvd"):
 400        return loadPVD(filename)
 401
 402    ########################################################### polygonal mesh:
 403    else:
 404        if fl.endswith(".vtk"):  # read all legacy vtk types
 405            reader = vtki.new("DataSetReader")
 406            reader.ReadAllScalarsOn()
 407            reader.ReadAllVectorsOn()
 408            reader.ReadAllTensorsOn()
 409            reader.ReadAllFieldsOn()
 410            reader.ReadAllNormalsOn()
 411            reader.ReadAllColorScalarsOn()
 412        elif fl.endswith(".ply"):
 413            reader = vtki.new("PLYReader")
 414        elif fl.endswith(".obj"):
 415            reader = vtki.new("OBJReader")
 416            reader.SetGlobalWarningDisplay(0) # suppress warnings issue #980
 417        elif fl.endswith(".stl"):
 418            reader = vtki.new("STLReader")
 419        elif fl.endswith(".byu") or fl.endswith(".g"):
 420            reader = vtki.new("BYUReader")
 421        elif fl.endswith(".foam"):  # OpenFoam
 422            reader = vtki.new("OpenFOAMReader")
 423        elif fl.endswith(".pvd"):
 424            reader = vtki.new("XMLGenericDataObjectReader")
 425        elif fl.endswith(".vtp"):
 426            reader = vtki.new("XMLPolyDataReader")
 427        elif fl.endswith(".vts"):
 428            reader = vtki.new("XMLStructuredGridReader")
 429        elif fl.endswith(".vtu"):
 430            reader = vtki.new("XMLUnstructuredGridReader")
 431        elif fl.endswith(".vtr"):
 432            reader = vtki.new("XMLRectilinearGridReader")
 433        elif fl.endswith(".pvtr"):
 434            reader = vtki.new("XMLPRectilinearGridReader")
 435        elif fl.endswith("pvtu"):
 436            reader = vtki.new("XMLPUnstructuredGridReader")
 437        elif fl.endswith(".txt") or fl.endswith(".xyz") or fl.endswith(".dat"):
 438            reader = vtki.new("ParticleReader")  # (format is x, y, z, scalar)
 439        elif fl.endswith(".facet"):
 440            reader = vtki.new("FacetReader")
 441        else:
 442            return None
 443
 444        reader.SetFileName(filename)
 445        reader.Update()
 446        routput = reader.GetOutput()
 447
 448        if not routput:
 449            vedo.logger.error(f"unable to load {filename}") 
 450            return None
 451
 452        if isinstance(routput, vtki.vtkUnstructuredGrid):
 453            objt = vedo.UnstructuredGrid(routput)
 454
 455        else:
 456            objt = Mesh(routput)
 457            if fl.endswith(".txt") or fl.endswith(".xyz") or fl.endswith(".dat"):
 458                objt.point_size(4)
 459
 460    objt.filename = filename
 461    objt.file_size, objt.created = file_info(filename)
 462    return objt
 463
 464
 465def download(url: str, force=False, verbose=True) -> str:
 466    """
 467    Retrieve a file from a URL, save it locally and return its path.
 468    Use `force=True` to force a reload and discard cached copies.
 469    """
 470    if not url.startswith("https://"):
 471        # assume it's a file so no need to download
 472        return url
 473    url = url.replace("www.dropbox", "dl.dropbox")
 474
 475    if "github.com" in url:
 476        url = url.replace("/blob/", "/raw/")
 477
 478    basename = os.path.basename(url)
 479
 480    if "?" in basename:
 481        basename = basename.split("?")[0]
 482
 483    home_directory = os.path.expanduser("~")
 484    cachedir = os.path.join(home_directory, settings.cache_directory, "vedo")
 485    fname = os.path.join(cachedir, basename)
 486    # Create the directory if it does not exist
 487    if not os.path.exists(cachedir):
 488        os.makedirs(cachedir)
 489
 490    if not force and os.path.exists(fname):
 491        if verbose:
 492            colors.printc("reusing cached file:", fname)
 493        return fname
 494
 495    try:
 496        from urllib.request import urlopen, Request
 497        req = Request(url, headers={"User-Agent": "Mozilla/5.0"})
 498        if verbose:
 499            colors.printc("reading", basename, "from", url.split("/")[2][:40], "...", end="")
 500
 501    except ImportError:
 502        import urllib2
 503        import contextlib
 504        urlopen = lambda url_: contextlib.closing(urllib2.urlopen(url_))
 505        req = url
 506        if verbose:
 507            colors.printc("reading", basename, "from", url.split("/")[2][:40], "...", end="")
 508
 509    with urlopen(req) as response, open(fname, "wb") as output:
 510        output.write(response.read())
 511
 512    if verbose:
 513        colors.printc(" done.")
 514    return fname
 515
 516
 517########################################################################
 518# def download_new(url, to_local_file="", force=False, verbose=True):
 519#     """
 520#     Downloads a file from `url` to `to_local_file` if the local copy is outdated.
 521
 522#     Arguments:
 523#         url : (str)
 524#             The URL to download the file from.
 525#         to_local_file : (str)
 526#             The local file name to save the file to. 
 527#             If not specified, the file name will be the same as the remote file name
 528#             in the directory specified by `settings.cache_directory + "/vedo"`.
 529#         force : (bool)
 530#             Force a new download even if the local file is up to date.
 531#         verbose : (bool)
 532#             Print verbose messages.
 533#     """
 534#     if not url.startswith("https://"):
 535#         if os.path.exists(url):
 536#             # Assume the url is already the local file path
 537#             return url
 538#         else:
 539#             raise FileNotFoundError(f"File not found: {url}")
 540
 541#     from datetime import datetime
 542#     import requests
 543
 544#     url = url.replace("www.dropbox", "dl.dropbox")
 545
 546#     if "github.com" in url:
 547#         url = url.replace("/blob/", "/raw/")
 548
 549#     # Get the user's home directory
 550#     home_directory = os.path.expanduser("~")
 551
 552#     # Define the path for the cache directory
 553#     cachedir = os.path.join(home_directory, settings.cache_directory, "vedo")
 554
 555#     # Create the directory if it does not exist
 556#     if not os.path.exists(cachedir):
 557#         os.makedirs(cachedir)
 558
 559#     if not to_local_file:
 560#         basename = os.path.basename(url)
 561#         if "?" in basename:
 562#             basename = basename.split("?")[0]
 563#         to_local_file = os.path.join(cachedir, basename)
 564#         if verbose: print(f"Using local file name: {to_local_file}")
 565
 566#     # Check if the local file exists and get its last modified time
 567#     if os.path.exists(to_local_file):
 568#         to_local_file_modified_time = os.path.getmtime(to_local_file)
 569#     else:
 570#         to_local_file_modified_time = 0
 571
 572#     # Send a HEAD request to get last modified time of the remote file
 573#     response = requests.head(url)
 574#     if 'Last-Modified' in response.headers:
 575#         remote_file_modified_time = datetime.strptime(
 576#             response.headers['Last-Modified'], '%a, %d %b %Y %H:%M:%S GMT'
 577#         ).timestamp()
 578#     else:
 579#         # If the Last-Modified header not available, assume file needs to be downloaded
 580#         remote_file_modified_time = float('inf')
 581
 582#     # Download the file if the remote file is newer
 583#     if force or remote_file_modified_time > to_local_file_modified_time:
 584#         response = requests.get(url)
 585#         with open(to_local_file, 'wb') as file:
 586#             file.write(response.content)
 587#             if verbose: print(f"Downloaded file from {url} -> {to_local_file}")
 588#     else:
 589#         if verbose: print("Local file is up to date.")
 590#     return to_local_file
 591
 592
 593########################################################################
 594def gunzip(filename: str) -> str:
 595    """Unzip a `.gz` file to a temporary file and returns its path."""
 596    if not filename.endswith(".gz"):
 597        # colors.printc("gunzip() error: file must end with .gz", c='r')
 598        return filename
 599
 600    import gzip
 601
 602    tmp_file = NamedTemporaryFile(delete=False)
 603    tmp_file.name = os.path.join(
 604        os.path.dirname(tmp_file.name), os.path.basename(filename).replace(".gz", "")
 605    )
 606    inF = gzip.open(filename, "rb")
 607    with open(tmp_file.name, "wb") as outF:
 608        outF.write(inF.read())
 609    inF.close()
 610    return tmp_file.name
 611
 612########################################################################
 613def file_info(file_path: str) -> Tuple[str, str]:
 614    """Return the file size and creation time of input file"""
 615    siz, created = "", ""
 616    if os.path.isfile(file_path):
 617        f_info = os.stat(file_path)
 618        num = f_info.st_size
 619        for x in ["B", "KB", "MB", "GB", "TB"]:
 620            if num < 1024.0:
 621                break
 622            num /= 1024.0
 623        siz = "%3.1f%s" % (num, x)
 624        created = time.ctime(os.path.getmtime(file_path))
 625    return siz, created
 626
 627
 628###################################################################
 629def loadStructuredPoints(filename: Union[str, os.PathLike], as_points=True):
 630    """
 631    Load and return a `vtkStructuredPoints` object from file.
 632    
 633    If `as_points` is True, return a `Points` object
 634    instead of a `vtkStructuredPoints`.
 635    """
 636    filename = str(filename)
 637    reader = vtki.new("StructuredPointsReader")
 638    reader.SetFileName(filename)
 639    reader.Update()
 640    if as_points:
 641        v2p = vtki.new("ImageToPoints")
 642        v2p.SetInputData(reader.GetOutput())
 643        v2p.Update()
 644        pts = Points(v2p.GetOutput())
 645        return pts
 646    return reader.GetOutput()
 647
 648########################################################################
 649def loadStructuredGrid(filename: Union[str, os.PathLike]):
 650    """Load and return a `vtkStructuredGrid` object from file."""
 651    filename = str(filename)
 652    if filename.endswith(".vts"):
 653        reader = vtki.new("XMLStructuredGridReader")
 654    else:
 655        reader = vtki.new("StructuredGridReader")
 656    reader.SetFileName(filename)
 657    reader.Update()
 658    return reader.GetOutput()
 659
 660
 661###################################################################
 662def load3DS(filename: Union[str, os.PathLike]) -> Assembly:
 663    """Load `3DS` file format from file."""
 664    filename = str(filename)
 665    renderer = vtki.vtkRenderer()
 666    renWin = vtki.vtkRenderWindow()
 667    renWin.AddRenderer(renderer)
 668
 669    importer = vtki.new("3DSImporter")
 670    importer.SetFileName(filename)
 671    importer.ComputeNormalsOn()
 672    importer.SetRenderWindow(renWin)
 673    importer.Update()
 674
 675    actors = renderer.GetActors()  # vtkActorCollection
 676    acts = []
 677    for i in range(actors.GetNumberOfItems()):
 678        a = actors.GetItemAsObject(i)
 679        acts.append(a)
 680    del renWin
 681
 682    wrapped_acts = []
 683    for a in acts:
 684        try:
 685            newa = Mesh(a.GetMapper().GetInput())
 686            newa.actor = a
 687            wrapped_acts.append(newa)
 688            # print("loaded 3DS object", [a])
 689        except:
 690            print("ERROR: cannot load 3DS object part", [a])
 691    return vedo.Assembly(wrapped_acts)
 692
 693########################################################################
 694def loadOFF(filename: Union[str, os.PathLike]) -> Mesh:
 695    """Read the OFF file format (polygonal mesh)."""
 696    filename = str(filename)
 697    with open(filename, "r", encoding="UTF-8") as f:
 698        lines = f.readlines()
 699
 700    vertices = []
 701    faces = []
 702    NumberOfVertices = 0
 703    i = -1
 704    for text in lines:
 705        if len(text) == 0:
 706            continue
 707        if text == "\n":
 708            continue
 709        if "#" in text:
 710            continue
 711        if "OFF" in text:
 712            continue
 713
 714        ts = text.split()
 715        n = len(ts)
 716
 717        if not NumberOfVertices and n > 1:
 718            NumberOfVertices, NumberOfFaces = int(ts[0]), int(ts[1])
 719            continue
 720        i += 1
 721
 722        if i < NumberOfVertices and n == 3:
 723            x, y, z = float(ts[0]), float(ts[1]), float(ts[2])
 724            vertices.append([x, y, z])
 725
 726        ids = []
 727        if NumberOfVertices <= i < (NumberOfVertices + NumberOfFaces + 1) and n > 2:
 728            ids += [int(xx) for xx in ts[1:]]
 729            faces.append(ids)
 730
 731    return Mesh(utils.buildPolyData(vertices, faces))
 732
 733########################################################################
 734def loadGeoJSON(filename: Union[str, os.PathLike]) -> Mesh:
 735    """Load GeoJSON files."""
 736    filename = str(filename)
 737    jr = vtki.new("GeoJSONReader")
 738    jr.SetFileName(filename)
 739    jr.Update()
 740    return Mesh(jr.GetOutput())
 741
 742########################################################################
 743def loadDolfin(filename: Union[str, os.PathLike]) -> Union[Mesh, "vedo.TetMesh", None]:
 744    """
 745    Reads a `Fenics/Dolfin` file format (.xml or .xdmf).
 746
 747    Return a `Mesh` or a `TetMesh` object.
 748    """
 749    filename = str(filename)
 750    try:
 751        import dolfin
 752    except ImportError:
 753        vedo.logger.error("loadDolfin(): dolfin module not found. Install with:")
 754        vedo.logger.error("  conda create -n fenics -c conda-forge fenics")
 755        vedo.logger.error("  conda install conda-forge::mshr")
 756        vedo.logger.error("  conda activate fenics")
 757        return None
 758
 759    if filename.lower().endswith(".xdmf"):
 760        f = dolfin.XDMFFile(filename)
 761        m = dolfin.Mesh()
 762        f.read(m)
 763    else:
 764        m = dolfin.Mesh(filename)
 765    
 766    cells = m.cells()
 767    verts = m.coordinates()
 768
 769    if cells.size and verts.size:
 770        if len(cells[0]) == 4:  # tetrahedral mesh
 771            return vedo.TetMesh([verts, cells])
 772        elif len(cells[0]) == 3:  # triangular mesh
 773            return Mesh([verts, cells])
 774    
 775    return None
 776
 777
 778########################################################################
 779def loadPVD(filename: Union[str, os.PathLike]) -> Union[List[Any], None]:
 780    """Read paraview files."""
 781    filename = str(filename)
 782    import xml.etree.ElementTree as et
 783
 784    tree = et.parse(filename)
 785
 786    dname = os.path.dirname(filename)
 787    if not dname:
 788        dname = "."
 789
 790    listofobjs = []
 791    for coll in tree.getroot():
 792        for dataset in coll:
 793            fname = dataset.get("file")
 794            if not fname:
 795                continue
 796            ob = load(dname + "/" + fname)
 797            tm = dataset.get("timestep")
 798            if tm:
 799                ob.time = tm
 800            listofobjs.append(ob)
 801    if len(listofobjs) == 1:
 802        return listofobjs[0]
 803    if len(listofobjs) == 0:
 804        return None
 805    return listofobjs
 806
 807########################################################################
 808def loadNeutral(filename: Union[str, os.PathLike]) -> "vedo.TetMesh":
 809    """
 810    Reads a `Neutral` tetrahedral file format.
 811
 812    Returns an `TetMesh` object.
 813    """
 814    filename = str(filename)
 815    with open(filename, "r", encoding="UTF-8") as f:
 816        lines = f.readlines()
 817
 818    ncoords = int(lines[0])
 819    coords = []
 820    for i in range(1, ncoords + 1):
 821        x, y, z = lines[i].split()
 822        coords.append([float(x), float(y), float(z)])
 823
 824    ntets = int(lines[ncoords + 1])
 825    idolf_tets = []
 826    for i in range(ncoords + 2, ncoords + ntets + 2):
 827        text = lines[i].split()
 828        v0, v1, v2, v3 = int(text[1])-1, int(text[2])-1, int(text[3])-1, int(text[4])-1
 829        idolf_tets.append([v0, v1, v2, v3])
 830
 831    return vedo.TetMesh([coords, idolf_tets])
 832
 833########################################################################
 834def loadGmesh(filename: Union[str, os.PathLike]) -> Mesh:
 835    """Reads a `gmesh` file format. Return an `Mesh` object."""
 836    filename = str(filename)
 837    with open(filename, "r", encoding="UTF-8") as f:
 838        lines = f.readlines()
 839
 840    nnodes = 0
 841    index_nodes = 0
 842    for i, line in enumerate(lines):
 843        if "$Nodes" in line:
 844            index_nodes = i + 1
 845            nnodes = int(lines[index_nodes])
 846            break
 847    node_coords = []
 848    for i in range(index_nodes + 1, index_nodes + 1 + nnodes):
 849        cn = lines[i].split()
 850        node_coords.append([float(cn[1]), float(cn[2]), float(cn[3])])
 851
 852    nelements = 0
 853    index_elements = 0
 854    for i, line in enumerate(lines):
 855        if "$Elements" in line:
 856            index_elements = i + 1
 857            nelements = int(lines[index_elements])
 858            break
 859    elements = []
 860    for i in range(index_elements + 1, index_elements + 1 + nelements):
 861        ele = lines[i].split()
 862        elements.append([int(ele[-3]), int(ele[-2]), int(ele[-1])])
 863
 864    poly = utils.buildPolyData(node_coords, elements, index_offset=1)
 865    return Mesh(poly)
 866
 867########################################################################
 868def loadPCD(filename: Union[str, os.PathLike]) -> Points:
 869    """Return a `Mesh` made of only vertex points
 870    from the `PointCloud` library file format.
 871    
 872    Returns an `Points` object.
 873    """
 874    filename = str(filename)
 875    with open(filename, "r", encoding="UTF-8") as f:
 876        lines = f.readlines()
 877
 878    start = False
 879    pts = []
 880    N, expN = 0, 0
 881    for text in lines:
 882        if start:
 883            if N >= expN:
 884                break
 885            l = text.split()
 886            pts.append([float(l[0]), float(l[1]), float(l[2])])
 887            N += 1
 888        if not start and "POINTS" in text:
 889            expN = int(text.split()[1])
 890        if not start and "DATA ascii" in text:
 891            start = True
 892    if expN != N:
 893        vedo.logger.warning(f"Mismatch in PCD file {expN} != {len(pts)}")
 894    poly = utils.buildPolyData(pts)
 895    return Points(poly).point_size(4)
 896
 897#########################################################################
 898def from_numpy(d: dict) -> Mesh:
 899    # recreate a mesh from numpy arrays
 900    keys = d.keys()
 901
 902    points = d["points"]
 903    cells = d["cells"] if "cells" in keys else None
 904    lines = d["lines"] if "lines" in keys else None
 905
 906    msh = Mesh([points, cells, lines])
 907
 908    if "pointdata" in keys and isinstance(d["pointdata"], dict):
 909        for arrname, arr in d["pointdata"].items():
 910            msh.pointdata[arrname] = arr
 911    if "celldata" in keys and isinstance(d["celldata"], dict):
 912        for arrname, arr in d["celldata"].items():
 913            msh.celldata[arrname] = arr
 914    if "metadata" in keys and isinstance(d["metadata"], dict):
 915        for arrname, arr in d["metadata"].items():
 916            msh.metadata[arrname] = arr
 917
 918    prp = msh.properties
 919    prp.SetAmbient(d['ambient'])
 920    prp.SetDiffuse(d['diffuse'])
 921    prp.SetSpecular(d['specular'])
 922    prp.SetSpecularPower(d['specularpower'])
 923    prp.SetSpecularColor(d['specularcolor'])
 924
 925    prp.SetInterpolation(0)
 926    # prp.SetInterpolation(d['shading'])
 927
 928    prp.SetOpacity(d['alpha'])
 929    prp.SetRepresentation(d['representation'])
 930    prp.SetPointSize(d['pointsize'])
 931    if d['color'] is not None:
 932        msh.color(d['color'])
 933    if "lighting_is_on" in d.keys(): 
 934        prp.SetLighting(d['lighting_is_on'])
 935    # Must check keys for backwards compatibility:
 936    if "linecolor" in d.keys() and d['linecolor'] is not None:
 937        msh.linecolor(d['linecolor'])
 938    if "backcolor" in d.keys() and d['backcolor'] is not None:
 939        msh.backcolor(d['backcolor'])
 940
 941    if d['linewidth'] is not None:
 942        msh.linewidth(d['linewidth'])
 943    if "edge_visibility" in d.keys(): 
 944        prp.SetEdgeVisibility(d['edge_visibility']) # new
 945
 946    lut_list  = d["LUT"]
 947    lut_range = d["LUT_range"]
 948    ncols = len(lut_list)
 949    lut = vtki.vtkLookupTable()
 950    lut.SetNumberOfTableValues(ncols)
 951    lut.SetRange(lut_range)
 952    for i in range(ncols):
 953        r, g, b, a = lut_list[i]
 954        lut.SetTableValue(i, r, g, b, a)
 955    lut.Build()
 956    msh.mapper.SetLookupTable(lut)
 957    msh.mapper.SetScalarRange(lut_range)
 958
 959    try: # NEW in vedo 5.0
 960        arname = d["array_name_to_color_by"]
 961        msh.mapper.SetArrayName(arname)
 962        msh.mapper.SetInterpolateScalarsBeforeMapping(
 963            d["interpolate_scalars_before_mapping"])
 964        msh.mapper.SetUseLookupTableScalarRange(
 965            d["use_lookup_table_scalar_range"])
 966        msh.mapper.SetScalarRange(d["scalar_range"])
 967        msh.mapper.SetScalarVisibility(d["scalar_visibility"])
 968        msh.mapper.SetScalarMode(d["scalar_mode"])
 969        msh.mapper.SetColorMode(d["color_mode"])
 970        if d["scalar_visibility"]:
 971            if d["scalar_mode"] == 1:
 972                msh.dataset.GetPointData().SetActiveScalars(arname)
 973            if d["scalar_mode"] == 2:
 974                msh.dataset.GetCellData().SetActiveScalars(arname)
 975
 976        if "texture_array" in keys and d["texture_array"] is not None:
 977            # recreate a vtkTexture object from numpy arrays:
 978            t = vtki.vtkTexture()
 979            t.SetInterpolate(d["texture_interpolate"])
 980            t.SetRepeat(d["texture_repeat"])
 981            t.SetQuality(d["texture_quality"])
 982            t.SetColorMode(d["texture_color_mode"])
 983            t.SetMipmap(d["texture_mipmap"])
 984            t.SetBlendingMode(d["texture_blending_mode"])
 985            t.SetEdgeClamp(d["texture_edge_clamp"])
 986            t.SetBorderColor(d["texture_border_color"])
 987            msh.actor.SetTexture(t)
 988            tcarray = None
 989            for arrname in msh.pointdata.keys():
 990                if "Texture" in arrname or "TCoord" in arrname:
 991                    tcarray = arrname
 992                    break
 993            if tcarray is not None:
 994                t.SetInputData(vedo.Image(d["texture_array"]).dataset)
 995                msh.pointdata.select_texture_coords(tcarray)
 996
 997        # print("color_mode", d["color_mode"])
 998        # print("scalar_mode", d["scalar_mode"])
 999        # print("scalar_range", d["scalar_range"])
1000        # print("scalar_visibility", d["scalar_visibility"])
1001        # print("array_name_to_color_by", arname)
1002    except KeyError:
1003        pass
1004
1005    if "time" in keys: msh.time = d["time"]
1006    if "name" in keys: msh.name = d["name"]
1007    # if "info" in keys: msh.info = d["info"]
1008    if "filename" in keys: msh.filename = d["filename"]
1009    if "pickable" in keys: msh.pickable(d["pickable"])
1010    if "dragable" in keys: msh.draggable(d["dragable"])
1011    return msh
1012
1013#############################################################################
1014def _import_npy(fileinput: Union[str, os.PathLike]) -> "vedo.Plotter":
1015    """Import a vedo scene from numpy format."""
1016    fileinput = str(fileinput)
1017
1018    fileinput = download(fileinput, verbose=False, force=True)
1019    if fileinput.endswith(".npy"):
1020        data = np.load(fileinput, allow_pickle=True, encoding="latin1").flatten()[0]
1021    elif fileinput.endswith(".npz"):
1022        data = np.load(fileinput, allow_pickle=True)["vedo_scenes"][0]
1023
1024    if "use_parallel_projection" in data.keys():
1025        vedo.settings.use_parallel_projection = data["use_parallel_projection"]
1026    if "use_polygon_offset" in data.keys():
1027        vedo.settings.use_polygon_offset = data["use_polygon_offset"]
1028    if "polygon_offset_factor" in data.keys():
1029        vedo.settings.polygon_offset_factor = data["polygon_offset_factor"]
1030    if "polygon_offset_units" in data.keys():
1031        vedo.settings.polygon_offset_units = data["polygon_offset_units"]
1032    if "interpolate_scalars_before_mapping" in data.keys():
1033        vedo.settings.interpolate_scalars_before_mapping = data["interpolate_scalars_before_mapping"]
1034    if "default_font" in data.keys():
1035        vedo.settings.default_font = data["default_font"]
1036    if "use_depth_peeling" in data.keys():
1037        vedo.settings.use_depth_peeling = data["use_depth_peeling"]
1038
1039    axes = data.pop("axes", 4) # UNUSED
1040    title = data.pop("title", "")
1041    backgrcol  = data.pop("backgrcol", "white")
1042    backgrcol2 = data.pop("backgrcol2", None)
1043    cam = data.pop("camera", None)
1044
1045    if data["shape"] != (1, 1):
1046        data["size"] = "auto"  # disable size
1047
1048    plt = vedo.Plotter(
1049        size=data["size"],  # not necessarily a good idea to set it
1050        axes=axes,          # must be zero to avoid recreating the axes
1051        title=title,
1052        bg=backgrcol,
1053        bg2=backgrcol2,
1054    )
1055
1056    if cam:
1057        if "pos" in cam.keys():
1058            plt.camera.SetPosition(cam["pos"])
1059        if "focalPoint" in cam.keys(): # obsolete
1060            plt.camera.SetFocalPoint(cam["focalPoint"])
1061        if "focal_point" in cam.keys():
1062            plt.camera.SetFocalPoint(cam["focal_point"])
1063        if "viewup" in cam.keys():
1064            plt.camera.SetViewUp(cam["viewup"])
1065        if "distance" in cam.keys():
1066            plt.camera.SetDistance(cam["distance"])
1067        if "clippingRange" in cam.keys(): # obsolete
1068            plt.camera.SetClippingRange(cam["clippingRange"])
1069        if "clipping_range" in cam.keys():
1070            plt.camera.SetClippingRange(cam["clipping_range"])
1071        if "parallel_scale" in cam.keys():
1072            plt.camera.SetParallelScale(cam["parallel_scale"])
1073
1074    ##############################################
1075    objs = []
1076    for d in data["objects"]:
1077        ### Mesh
1078        if d['type'].lower() == 'mesh':
1079            obj = from_numpy(d)
1080
1081        ### Assembly
1082        elif d['type'].lower() == 'assembly':
1083            assacts = []
1084            for ad in d["actors"]:
1085                assacts.append(from_numpy(ad))
1086            obj = Assembly(assacts)
1087            obj.SetScale(d["scale"])
1088            obj.SetPosition(d["position"])
1089            obj.SetOrientation(d["orientation"])
1090            obj.SetOrigin(d["origin"])
1091
1092        ### Volume
1093        elif d['type'].lower() == 'volume':
1094            obj = Volume(d["array"])
1095            obj.spacing(d["spacing"])
1096            obj.origin(d["origin"])
1097            if "jittering" in d.keys(): obj.jittering(d["jittering"])
1098            obj.mode(d["mode"])
1099            obj.color(d["color"])
1100            obj.alpha(d["alpha"])
1101            obj.alpha_gradient(d["alphagrad"])
1102
1103        ### TetMesh
1104        elif d['type'].lower() == 'tetmesh':
1105            raise NotImplementedError("TetMesh not supported yet")
1106
1107        ### ScalarBar2D
1108        elif d['type'].lower() == 'scalarbar2d':
1109            raise NotImplementedError("ScalarBar2D not supported yet")
1110
1111        ### Image
1112        elif d['type'].lower() == 'image':
1113            obj = Image(d["array"])
1114            obj.alpha(d["alpha"])
1115            obj.actor.SetScale(d["scale"])
1116            obj.actor.SetPosition(d["position"])
1117            obj.actor.SetOrientation(d["orientation"])
1118            obj.actor.SetOrigin(d["origin"])
1119
1120        ### Text2D
1121        elif d['type'].lower() == 'text2d':
1122            obj = vedo.shapes.Text2D(d["text"], font=d["font"], c=d["color"])
1123            obj.pos(d["position"]).size(d["size"])
1124            obj.background(d["bgcol"], d["alpha"])
1125            if d["frame"]:
1126                obj.frame(d["bgcol"])
1127        
1128        else:
1129            obj = None
1130            # vedo.logger.warning(f"Cannot import object {d}")
1131            pass
1132
1133        if obj:
1134            keys = d.keys()
1135            if "time" in keys: obj.time = d["time"]
1136            if "name" in keys: obj.name = d["name"]
1137            # if "info" in keys: obj.info = d["info"]
1138            if "filename" in keys: obj.filename = d["filename"]
1139            objs.append(obj)
1140
1141    plt.add(objs)
1142    plt.resetcam = False
1143    return plt
1144
1145###########################################################
1146def loadImageData(filename: Union[str, os.PathLike]) -> Union[vtki.vtkImageData, None]:
1147    """Read and return a `vtkImageData` object from file."""
1148    filename = str(filename)
1149    if ".tif" in filename.lower():
1150        reader = vtki.new("TIFFReader")
1151        # print("GetOrientationType ", reader.GetOrientationType())
1152        reader.SetOrientationType(vedo.settings.tiff_orientation_type)
1153    elif ".slc" in filename.lower():
1154        reader = vtki.new("SLCReader")
1155        if not reader.CanReadFile(filename):
1156            vedo.logger.error(f"sorry, bad SLC file {filename}")
1157            return None
1158    elif ".vti" in filename.lower():
1159        reader = vtki.new("XMLImageDataReader")
1160    elif ".mhd" in filename.lower():
1161        reader = vtki.new("MetaImageReader")
1162    elif ".dem" in filename.lower():
1163        reader = vtki.new("DEMReader")
1164    elif ".nii" in filename.lower():
1165        reader = vtki.new("NIFTIImageReader")
1166    elif ".nrrd" in filename.lower():
1167        reader = vtki.new("NrrdReader")
1168        if not reader.CanReadFile(filename):
1169            vedo.logger.error(f"sorry, bad NRRD file {filename}")
1170            return None
1171    else:
1172        vedo.logger.error(f"cannot read file {filename}")
1173        return None
1174    reader.SetFileName(filename)
1175    reader.Update()
1176    return reader.GetOutput()
1177
1178###########################################################
1179def write(objct: Any, fileoutput: Union[str, os.PathLike], binary=True) -> Any:
1180    """
1181    Write object to file. Same as `save()`.
1182
1183    Supported extensions are:
1184    
1185    - `vtk, vti, ply, obj, stl, byu, vtp, vti, mhd, xyz, xml, tif, png, bmp`
1186    """
1187    fileoutput = str(fileoutput)
1188
1189    ###############################
1190    if isinstance(objct, Assembly):
1191        dd = to_numpy(objct)
1192        sdict = {"objects": [dd]}
1193        np.save(fileoutput, sdict)
1194        return objct
1195    
1196    ###############################
1197    obj = objct.dataset
1198
1199    try:
1200        # check if obj is a Mesh.actor and has a transform
1201        M = objct.actor.GetMatrix()
1202        if M and not M.IsIdentity():
1203            obj = objct.apply_transform_from_actor()
1204            obj = objct.dataset
1205            vedo.logger.info(
1206                f"object '{objct.name}' "
1207                "was manually moved. Writing uses current position."
1208            )
1209    except:
1210        pass
1211
1212    fr = fileoutput.lower()
1213    if fr.endswith(".vtk"):
1214        writer = vtki.new("DataSetWriter")
1215    elif fr.endswith(".ply"):
1216        writer = vtki.new("PLYWriter")
1217        writer.AddComment("PLY file generated by vedo")
1218        lut = objct.mapper.GetLookupTable()
1219        if lut:
1220            pscal = obj.GetPointData().GetScalars()
1221            if not pscal:
1222                pscal = obj.GetCellData().GetScalars()
1223            if pscal and pscal.GetName():
1224                writer.SetArrayName(pscal.GetName())
1225            writer.SetLookupTable(lut)
1226    elif fr.endswith(".stl"):
1227        writer = vtki.new("STLWriter")
1228    elif fr.endswith(".vtp"):
1229        writer = vtki.new("XMLPolyDataWriter")
1230    elif fr.endswith(".vtu"):
1231        writer = vtki.new("XMLUnstructuredGridWriter")
1232    elif fr.endswith(".xyz"):
1233        writer = vtki.new("SimplePointsWriter")
1234    elif fr.endswith(".facet"):
1235        writer = vtki.new("FacetWriter")
1236    elif fr.endswith(".vti"):
1237        writer = vtki.new("XMLImageDataWriter")
1238    elif fr.endswith(".vtr"):
1239        writer = vtki.new("XMLRectilinearGridWriter")
1240    elif fr.endswith(".vtm"):
1241        g = vtki.new("MultiBlockDataGroupFilter")
1242        for ob in objct:
1243            try:
1244                g.AddInputData(ob)
1245            except TypeError:
1246                vedo.logger.warning("cannot save object of type", type(ob))
1247        g.Update()
1248        mb = g.GetOutputDataObject(0)
1249        wri = vtki.new("vtkXMLMultiBlockDataWriter")
1250        wri.SetInputData(mb)
1251        wri.SetFileName(fileoutput)
1252        wri.Write()
1253        return objct
1254    elif fr.endswith(".mhd"):
1255        writer = vtki.new("MetaImageWriter")
1256    elif fr.endswith(".nii"):
1257        writer = vtki.new("NIFTIImageWriter")
1258    elif fr.endswith(".png"):
1259        writer = vtki.new("PNGWriter")
1260    elif fr.endswith(".jpg"):
1261        writer = vtki.new("JPEGWriter")
1262    elif fr.endswith(".bmp"):
1263        writer = vtki.new("BMPWriter")
1264    elif fr.endswith(".tif") or fr.endswith(".tiff"):
1265        writer = vtki.new("TIFFWriter")
1266        writer.SetFileDimensionality(len(obj.GetDimensions()))
1267    elif fr.endswith(".obj"):
1268        with open(fileoutput, "w", encoding="UTF-8") as outF:
1269            outF.write("# OBJ file format with ext .obj\n")
1270            outF.write("# File generated by vedo\n")
1271
1272            for p in objct.vertices:
1273                outF.write("v {:.8g} {:.8g} {:.8g}\n".format(*p))
1274
1275            ptxt = objct.dataset.GetPointData().GetTCoords()
1276            if ptxt:
1277                ntxt = utils.vtk2numpy(ptxt)
1278                for vt in ntxt:
1279                    outF.write("vt " + str(vt[0]) + " " + str(vt[1]) + " 0.0\n")
1280
1281            if isinstance(objct, Mesh):
1282                for i, f in enumerate(objct.cells):
1283                    fs = ""
1284                    for fi in f:
1285                        if ptxt:
1286                            fs += f" {fi+1}/{fi+1}"
1287                        else:
1288                            fs += f" {fi+1}"
1289                    outF.write(f"f{fs}\n")
1290
1291                for l in objct.lines:
1292                    ls = ""
1293                    for li in l:
1294                        ls += str(li + 1) + " "
1295                    outF.write(f"l {ls}\n")
1296        return objct
1297
1298    elif fr.endswith(".off"):
1299        with open(fileoutput, "w", encoding="UTF-8") as outF:
1300            outF.write("OFF\n")
1301            outF.write(str(objct.npoints) + " " + str(objct.ncells) + " 0\n\n")
1302            for p in objct.vertices:
1303                outF.write(" ".join([str(i) for i in p]) + "\n")
1304            for c in objct.cells:
1305                outF.write(str(len(c)) + " " + " ".join([str(i) for i in c]) + "\n")
1306        return objct
1307
1308    elif fr.endswith(".xml"):  # write tetrahedral dolfin xml
1309        vertices = objct.vertices.astype(str)
1310        faces = np.array(objct.cells).astype(str)
1311        ncoords = vertices.shape[0]
1312        with open(fileoutput, "w", encoding="UTF-8") as outF:
1313            outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
1314            outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
1315
1316            if len(faces[0]) == 4:  # write tetrahedral mesh
1317                ntets = faces.shape[0]
1318                outF.write('  <mesh celltype="tetrahedron" dim="3">\n')
1319                outF.write('    <vertices size="' + str(ncoords) + '">\n')
1320                for i in range(ncoords):
1321                    x, y, z = vertices[i]
1322                    outF.write('      <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
1323                outF.write('    </vertices>\n')
1324                outF.write('    <cells size="' + str(ntets) + '">\n')
1325                for i in range(ntets):
1326                    v0, v1, v2, v3 = faces[i]
1327                    outF.write('     <tetrahedron index="'+str(i)
1328                               + '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
1329
1330            elif len(faces[0]) == 3:  # write triangle mesh
1331                ntri = faces.shape[0]
1332                outF.write('  <mesh celltype="triangle" dim="2">\n')
1333                outF.write('    <vertices size="' + str(ncoords) + '">\n')
1334                for i in range(ncoords):
1335                    x, y, _ = vertices[i]
1336                    outF.write('      <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
1337                outF.write('    </vertices>\n')
1338                outF.write('    <cells size="' + str(ntri) + '">\n')
1339                for i in range(ntri):
1340                    v0, v1, v2 = faces[i]
1341                    outF.write('     <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
1342
1343            outF.write("    </cells>\n")
1344            outF.write("  </mesh>\n")
1345            outF.write("</dolfin>\n")
1346        return objct
1347
1348    else:
1349        vedo.logger.error(f"Unknown format {fileoutput}, file not saved")
1350        return objct
1351
1352    try:
1353        if binary:
1354            writer.SetFileTypeToBinary()
1355        else:
1356            writer.SetFileTypeToASCII()
1357    except AttributeError:
1358        pass
1359
1360    try:
1361        writer.SetInputData(obj)
1362        writer.SetFileName(fileoutput)
1363        writer.Write()
1364    except:
1365        vedo.logger.error(f"could not save {fileoutput}")
1366    return objct
1367
1368def save(obj: Any, fileoutput="out.png", binary=True) -> Any:
1369    """Save an object to file. Same as `write()`."""
1370    return write(obj, fileoutput, binary)
1371
1372def read(obj: Any, unpack=True, force=False) -> Any:
1373    """Read an object from file. Same as `load()`."""
1374    return load(obj, unpack, force)
1375
1376###############################################################################
1377def export_window(fileoutput: Union[str, os.PathLike], binary=False, plt=None) -> "vedo.Plotter":
1378    """
1379    Exporter which writes out the rendered scene into an HTML, X3D or Numpy file.
1380
1381    Example:
1382        - [export_x3d.py](https://github.com/marcomusy/vedo/tree/master/examples/other/export_x3d.py)
1383
1384        Check out the HTML generated webpage [here](https://vedo.embl.es/examples/embryo.html).
1385
1386        <img src='https://user-images.githubusercontent.com/32848391/57160341-c6ffbd80-6de8-11e9-95ff-7215ce642bc5.jpg' width="600"/>
1387
1388    .. note::
1389        the rendering window can also be exported to `numpy` file `scene.npz`
1390        by pressing `E` key at any moment during visualization.
1391    """
1392    fileoutput = str(fileoutput)
1393    if plt is None:
1394        plt = vedo.plotter_instance
1395
1396    fr = fileoutput.lower()
1397    ####################################################################
1398    if fr.endswith(".npy") or fr.endswith(".npz"):
1399        _export_npy(plt, fileoutput)
1400
1401    ####################################################################
1402    elif fr.endswith(".x3d"):
1403        # obj = plt.get_actors()
1404        # if plt.axes_instances:
1405        #     obj.append(plt.axes_instances[0])
1406
1407        # for a in obj:
1408        #     if isinstance(a, Assembly):
1409        #         plt.remove(a)
1410        #         plt.add(a.unpack())
1411
1412        plt.render()
1413
1414        exporter = vtki.new("X3DExporter")
1415        exporter.SetBinary(binary)
1416        exporter.FastestOff()
1417        exporter.SetInput(plt.window)
1418        exporter.SetFileName(fileoutput)
1419        # exporter.WriteToOutputStringOn()
1420        exporter.Update()
1421        exporter.Write()
1422
1423        wsize = plt.window.GetSize()
1424        x3d_html = _x3d_html_template.replace("~fileoutput", fileoutput)
1425        x3d_html = x3d_html.replace("~width",  str(wsize[0]))
1426        x3d_html = x3d_html.replace("~height", str(wsize[1]))
1427        with open(fileoutput.replace(".x3d", ".html"), "w", encoding="UTF-8") as outF:
1428            outF.write(x3d_html)
1429
1430    ####################################################################
1431    elif fr.endswith(".html"):
1432        savebk = vedo.notebook_backend
1433        vedo.notebook_backend = "k3d"
1434        vedo.settings.default_backend = "k3d"
1435        # acts = plt.get_actors()
1436        plt = vedo.backends.get_notebook_backend(plt.objects)
1437
1438        with open(fileoutput, "w", encoding="UTF-8") as fp:
1439            fp.write(plt.get_snapshot())
1440
1441        vedo.notebook_backend = savebk
1442        vedo.settings.default_backend = savebk
1443
1444    else:
1445        vedo.logger.error(f"export extension {fr.split('.')[-1]} is not supported")
1446
1447    return plt
1448
1449#########################################################################
1450def to_numpy(act: Any) -> dict:
1451    """Encode a vedo object to numpy format."""
1452
1453    ########################################################
1454    def _fillcommon(obj, adict):
1455        adict["filename"] = obj.filename
1456        adict["name"] = obj.name
1457        adict["time"] = obj.time
1458        adict["rendered_at"] = obj.rendered_at
1459        try:
1460            adict["transform"] = obj.transform.matrix
1461        except AttributeError:
1462            adict["transform"] = np.eye(4)
1463
1464    ####################################################################
1465    try:
1466        obj = act.retrieve_object()
1467    except AttributeError:
1468        obj = act
1469
1470    adict = {}
1471    adict["type"] = "unknown"
1472
1473    ######################################################## Points/Mesh
1474    if isinstance(obj, (Points, vedo.UnstructuredGrid)):
1475        adict["type"] = "Mesh"
1476        _fillcommon(obj, adict)
1477
1478        if isinstance(obj, vedo.UnstructuredGrid):
1479            # adict["type"] = "UnstructuredGrid"
1480            # adict["cells"] = obj.cells_as_flat_array
1481            poly = obj._actor.GetMapper().GetInput()
1482            mapper = obj._actor.GetMapper()
1483        else:
1484            poly = obj.dataset
1485            mapper = obj.mapper
1486
1487        adict["points"] = obj.vertices.astype(float)
1488
1489        adict["cells"] = None
1490        if poly.GetNumberOfPolys():
1491            adict["cells"] = obj.cells_as_flat_array
1492
1493        adict["lines"] = None
1494        if poly.GetNumberOfLines():
1495            adict["lines"] = obj.lines#_as_flat_array
1496
1497        adict["pointdata"] = {}
1498        for iname in obj.pointdata.keys():
1499            if "normals" in iname.lower():
1500                continue
1501            adict["pointdata"][iname] = obj.pointdata[iname]
1502
1503        adict["celldata"] = {}
1504        for iname in obj.celldata.keys():
1505            if "normals" in iname.lower():
1506                continue
1507            adict["celldata"][iname] = obj.celldata[iname]
1508        
1509        adict["metadata"] = {}
1510        for iname in obj.metadata.keys():
1511            adict["metadata"][iname] = obj.metadata[iname]
1512
1513        # NEW in vedo 5.0
1514        adict["scalar_mode"] = mapper.GetScalarMode()
1515        adict["array_name_to_color_by"] = mapper.GetArrayName()
1516        adict["color_mode"] = mapper.GetColorMode()
1517        adict["interpolate_scalars_before_mapping"] = mapper.GetInterpolateScalarsBeforeMapping()
1518        adict["use_lookup_table_scalar_range"] = mapper.GetUseLookupTableScalarRange()
1519        adict["scalar_range"] = mapper.GetScalarRange()
1520        adict["scalar_visibility"] = mapper.GetScalarVisibility()
1521        adict["pickable"] = obj.actor.GetPickable()
1522        adict["dragable"] = obj.actor.GetDragable()
1523
1524        # adict["color_map_colors"]  = mapper.GetColorMapColors()   #vtkUnsignedCharArray
1525        # adict["color_coordinates"] = mapper.GetColorCoordinates() #vtkFloatArray
1526        texmap = mapper.GetColorTextureMap()  #vtkImageData
1527        if texmap:
1528            adict["color_texture_map"] = vedo.Image(texmap).tonumpy()
1529            # print("color_texture_map", adict["color_texture_map"].shape)
1530
1531        adict["texture_array"] = None
1532        texture = obj.actor.GetTexture()
1533        if texture:
1534            adict["texture_array"] = vedo.Image(texture.GetInput()).tonumpy()
1535            adict["texture_interpolate"] = texture.GetInterpolate()
1536            adict["texture_repeat"] = texture.GetRepeat()
1537            adict["texture_quality"] = texture.GetQuality()
1538            adict["texture_color_mode"] = texture.GetColorMode()
1539            adict["texture_mipmap"] = texture.GetMipmap()
1540            adict["texture_blending_mode"] = texture.GetBlendingMode()
1541            adict["texture_edge_clamp"] = texture.GetEdgeClamp()
1542            adict["texture_border_color"] = texture.GetBorderColor()
1543            # print("tonumpy: texture", obj.name, adict["texture_array"].shape)
1544
1545        adict["LUT"] = None
1546        adict["LUT_range"] = None
1547        lut = mapper.GetLookupTable()
1548        if lut:
1549            nlut = lut.GetNumberOfTableValues()
1550            lutvals = []
1551            for i in range(nlut):
1552                v4 = lut.GetTableValue(i)  # (r, g, b, alpha)
1553                lutvals.append(v4)
1554            adict["LUT"] = np.array(lutvals, dtype=np.float32)
1555            adict["LUT_range"] = np.array(lut.GetRange())
1556
1557        prp = obj.properties
1558        adict["alpha"] = prp.GetOpacity()
1559        adict["representation"] = prp.GetRepresentation()
1560        adict["pointsize"] = prp.GetPointSize()
1561
1562        adict["linecolor"] = None
1563        adict["linewidth"] = None
1564        adict["edge_visibility"] = prp.GetEdgeVisibility() # new in vedo 5.0
1565        if prp.GetEdgeVisibility():
1566            adict["linewidth"] = prp.GetLineWidth()
1567            adict["linecolor"] = prp.GetEdgeColor()
1568
1569        adict["ambient"] = prp.GetAmbient()
1570        adict["diffuse"] = prp.GetDiffuse()
1571        adict["specular"] = prp.GetSpecular()
1572        adict["specularpower"] = prp.GetSpecularPower()
1573        adict["specularcolor"] = prp.GetSpecularColor()
1574        adict["shading"] = prp.GetInterpolation()  # flat phong..:
1575        adict["color"] = prp.GetColor()
1576        adict["lighting_is_on"] = prp.GetLighting()
1577        adict["backcolor"] = None
1578        if obj.actor.GetBackfaceProperty():
1579            adict["backcolor"] = obj.actor.GetBackfaceProperty().GetColor()
1580
1581    ######################################################## Volume
1582    elif isinstance(obj, Volume):
1583        adict["type"] = "Volume"
1584        _fillcommon(obj, adict)
1585        adict["array"] = obj.tonumpy()
1586        adict["mode"] = obj.mode()
1587        adict["spacing"] = obj.spacing()
1588        adict["origin"] = obj.origin()        
1589
1590        prp = obj.properties
1591        ctf = prp.GetRGBTransferFunction()
1592        otf = prp.GetScalarOpacity()
1593        gotf = prp.GetGradientOpacity()
1594        smin, smax = ctf.GetRange()
1595        xs = np.linspace(smin, smax, num=256, endpoint=True)
1596        cols, als, algrs = [], [], []
1597        for x in xs:
1598            cols.append(ctf.GetColor(x))
1599            als.append(otf.GetValue(x))
1600            if gotf:
1601                algrs.append(gotf.GetValue(x))
1602        adict["color"] = cols
1603        adict["alpha"] = als
1604        adict["alphagrad"] = algrs
1605
1606    ######################################################## Image
1607    elif isinstance(obj, Image):
1608        adict["type"] = "Image"
1609        _fillcommon(obj, adict)
1610        adict["array"] = obj.tonumpy()
1611        adict["scale"] = obj.actor.GetScale()
1612        adict["position"] = obj.actor.GetPosition()
1613        adict["orientation"] = obj.actor.GetOrientation()
1614        adict['origin'] = obj.actor.GetOrigin()
1615        adict["alpha"] = obj.alpha()
1616
1617    ######################################################## Text2D
1618    elif isinstance(obj, vedo.Text2D):
1619        adict["type"] = "Text2D"
1620        adict["rendered_at"] = obj.rendered_at
1621        adict["text"] = obj.text()
1622        adict["position"] = obj.GetPosition()
1623        adict["color"] = obj.properties.GetColor()
1624        adict["font"] = obj.fontname
1625        adict["size"] = obj.properties.GetFontSize() / 22.5
1626        adict["bgcol"] = obj.properties.GetBackgroundColor()
1627        adict["alpha"] = obj.properties.GetBackgroundOpacity()
1628        adict["frame"] = obj.properties.GetFrame()
1629    
1630    ######################################################## Assembly
1631    elif isinstance(obj, Assembly):
1632        adict["type"] = "Assembly"
1633        _fillcommon(obj, adict)
1634        adict["parts"] = []
1635        for a in obj.unpack():
1636            adict["parts"].append(to_numpy(a))
1637
1638    else:
1639        # vedo.logger.warning(f"to_numpy: cannot export object of type {type(obj)}")
1640        pass
1641
1642    return adict
1643
1644
1645#########################################################################
1646def _export_npy(plt, fileoutput="scene.npz") -> None:
1647    
1648    fileoutput = str(fileoutput)
1649
1650    sdict = {}
1651    sdict["shape"] = plt.shape
1652    sdict["sharecam"] = plt.sharecam
1653    sdict["camera"] = dict(
1654        pos=plt.camera.GetPosition(),
1655        focal_point=plt.camera.GetFocalPoint(),
1656        viewup=plt.camera.GetViewUp(),
1657        distance=plt.camera.GetDistance(),
1658        clipping_range=plt.camera.GetClippingRange(),
1659        parallel_scale=plt.camera.GetParallelScale(),
1660    )
1661    sdict["position"] = plt.pos
1662    sdict["size"] = plt.size
1663    sdict["axes"] = 0
1664    sdict["title"] = plt.title
1665    sdict["backgrcol"] = colors.get_color(plt.renderer.GetBackground())
1666    sdict["backgrcol2"] = None
1667    if plt.renderer.GetGradientBackground():
1668        sdict["backgrcol2"] = plt.renderer.GetBackground2()
1669    sdict["use_depth_peeling"] = plt.renderer.GetUseDepthPeeling()
1670    sdict["use_parallel_projection"] = plt.camera.GetParallelProjection()
1671    sdict["default_font"] = vedo.settings.default_font
1672
1673    sdict["objects"] = []
1674
1675    actors = plt.get_actors(include_non_pickables=True)
1676    # this ^ also retrieves Actors2D
1677    allobjs = []
1678    for i, a in enumerate(actors):
1679
1680        if not a.GetVisibility():
1681            continue
1682
1683        try:
1684            ob = a.retrieve_object()
1685            # print("get_actors",[ob], ob.name)
1686            if isinstance(ob, Assembly):
1687                asse_scale = ob.GetScale()
1688                asse_pos = ob.GetPosition()
1689                asse_ori = ob.GetOrientation()
1690                asse_org = ob.GetOrigin()
1691                for elem in ob.unpack():
1692                    elem.name = f"ASSEMBLY{i}_{ob.name}_{elem.name}"
1693                    # elem.info.update({"assembly": ob.name}) # TODO
1694                    # elem.info.update({"assembly_scale": asse_scale})
1695                    # elem.info.update({"assembly_position": asse_pos})
1696                    # elem.info.update({"assembly_orientation": asse_ori})
1697                    # elem.info.update({"assembly_origin": asse_org})
1698                    elem.metadata["assembly"] = ob.name
1699                    elem.metadata["assembly_scale"] = asse_scale
1700                    elem.metadata["assembly_position"] = asse_pos
1701                    elem.metadata["assembly_orientation"] = asse_ori
1702                    elem.metadata["assembly_origin"] = asse_org
1703                    allobjs.append(elem)
1704            else:
1705                allobjs.append(ob)
1706
1707        except AttributeError:
1708            # print()
1709            # vedo.logger.warning(f"Cannot retrieve object of type {type(a)}")
1710            pass
1711
1712    for a in allobjs:
1713        # print("to_numpy(): dumping", [a], a.name)
1714        # try:
1715        npobj = to_numpy(a)
1716        sdict["objects"].append(npobj)
1717        # except AttributeError:
1718        #     vedo.logger.warning(f"Cannot export object of type {type(a)}")
1719
1720    if fileoutput.endswith(".npz"):
1721        np.savez_compressed(fileoutput, vedo_scenes=[sdict])
1722    else:
1723        np.save(fileoutput, [sdict])
1724
1725
1726########################################################################
1727def import_window(fileinput: Union[str, os.PathLike]) -> Union["vedo.Plotter", None]:
1728    """
1729    Import a whole scene from a Numpy NPZ file.
1730
1731    Returns:
1732        `vedo.Plotter` instance
1733    """
1734    fileinput = str(fileinput)
1735
1736    if fileinput.endswith(".npy") or fileinput.endswith(".npz"):
1737        return _import_npy(fileinput)
1738    
1739    # elif ".obj" in fileinput.lower():
1740    #     meshes = load_obj(fileinput, mtl_file, texture_path)
1741    #     plt = vedo.Plotter()
1742    #     plt.add(meshes)
1743    #     return plt
1744
1745    # elif fileinput.endswith(".h5") or fileinput.endswith(".hdf5"):
1746    #     return _import_hdf5(fileinput) # in store/file_io_HDF5.py
1747
1748    return None
1749
1750
1751def load_obj(fileinput: Union[str, os.PathLike], mtl_file=None, texture_path=None) -> List[Mesh]:
1752    """
1753    Import a set of meshes from a OBJ wavefront file.
1754
1755    Arguments:
1756        mtl_file : (str)
1757            MTL file for OBJ wavefront files
1758        texture_path : (str)
1759            path of the texture files directory
1760
1761    Returns:
1762        `list(Mesh)`
1763    """
1764    fileinput = str(fileinput)
1765
1766    window = vtki.vtkRenderWindow()
1767    window.SetOffScreenRendering(1)
1768    renderer = vtki.vtkRenderer()
1769    window.AddRenderer(renderer)
1770
1771    importer = vtki.new("OBJImporter")
1772    importer.SetFileName(fileinput)
1773    if mtl_file is None:
1774        mtl_file = fileinput.replace(".obj", ".mtl").replace(".OBJ", ".MTL")
1775    if os.path.isfile(mtl_file):
1776        importer.SetFileNameMTL(mtl_file)
1777    if texture_path is None:
1778        texture_path = fileinput.replace(".obj", ".txt").replace(".OBJ", ".TXT")
1779    # since the texture_path may be a directory which contains textures
1780    if os.path.exists(texture_path):
1781        importer.SetTexturePath(texture_path)
1782    importer.SetRenderWindow(window)
1783    importer.Update()
1784
1785    actors = renderer.GetActors()
1786    actors.InitTraversal()
1787    objs = []
1788    for _ in range(actors.GetNumberOfItems()):
1789        vactor = actors.GetNextActor()
1790        msh = Mesh(vactor)
1791        msh.name = "OBJMesh"
1792        tx = vactor.GetTexture()
1793        if tx:
1794            msh.texture(tx)
1795        objs.append(msh)
1796    return objs
1797
1798
1799##########################################################
1800def screenshot(filename="screenshot.png", scale=1, asarray=False) -> Union["vedo.Plotter", np.ndarray, None]:
1801    """
1802    Save a screenshot of the current rendering window.
1803
1804    Alternatively, press key `Shift-S` in the rendering window to save a screenshot.
1805    You can also use keyword `screenshot` in `show(..., screenshot="pic.png")`.
1806
1807    Arguments:
1808        scale : (int)
1809            Set image magnification as an integer multiplicative factor.
1810            E.g. setting a magnification of 2 produces an image twice as large,
1811            but 10x slower to generate.
1812        asarray : (bool)
1813            Return a numpy array of the image
1814    """
1815    filename = str(filename)
1816    # print("calling screenshot", filename, scale, asarray)
1817
1818    if not vedo.plotter_instance or not vedo.plotter_instance.window:
1819        # vedo.logger.error("in screenshot(), rendering window is not present, skip.")
1820        return vedo.plotter_instance  ##########
1821    
1822    if vedo.plotter_instance.renderer:
1823        vedo.plotter_instance.renderer.ResetCameraClippingRange()
1824
1825    if asarray and scale == 1 and not vedo.plotter_instance.offscreen:
1826        nx, ny = vedo.plotter_instance.window.GetSize()
1827        arr = vtki.vtkUnsignedCharArray()
1828        vedo.plotter_instance.window.GetRGBACharPixelData(0, 0, nx-1, ny-1, 0, arr)
1829        narr = vedo.vtk2numpy(arr).T[:3].T.reshape([ny, nx, 3])
1830        narr = np.flip(narr, axis=0)
1831        return narr  ##########
1832
1833    ###########################
1834    if filename.endswith(".pdf"):
1835        writer = vtki.new("GL2PSExporter")
1836        writer.SetRenderWindow(vedo.plotter_instance.window)
1837        writer.Write3DPropsAsRasterImageOff()
1838        writer.SilentOn()
1839        writer.SetSortToBSP()
1840        writer.SetFileFormatToPDF()
1841        writer.SetFilePrefix(filename.replace(".pdf", ""))
1842        writer.Write()
1843        return vedo.plotter_instance  ##########
1844
1845    elif filename.endswith(".svg"):
1846        writer = vtki.new("GL2PSExporter")
1847        writer.SetRenderWindow(vedo.plotter_instance.window)
1848        writer.Write3DPropsAsRasterImageOff()
1849        writer.SilentOn()
1850        writer.SetSortToBSP()
1851        writer.SetFileFormatToSVG()
1852        writer.SetFilePrefix(filename.replace(".svg", ""))
1853        writer.Write()
1854        return vedo.plotter_instance  ##########
1855
1856    elif filename.endswith(".eps"):
1857        writer = vtki.new("GL2PSExporter")
1858        writer.SetRenderWindow(vedo.plotter_instance.window)
1859        writer.Write3DPropsAsRasterImageOff()
1860        writer.SilentOn()
1861        writer.SetSortToBSP()
1862        writer.SetFileFormatToEPS()
1863        writer.SetFilePrefix(filename.replace(".eps", ""))
1864        writer.Write()
1865        return vedo.plotter_instance  ##########
1866
1867    if settings.screeshot_large_image:
1868        w2if = vtki.new("RenderLargeImage")
1869        w2if.SetInput(vedo.plotter_instance.renderer)
1870        w2if.SetMagnification(scale)
1871    else:
1872        w2if = vtki.new("WindowToImageFilter")
1873        w2if.SetInput(vedo.plotter_instance.window)
1874        if hasattr(w2if, "SetScale"):
1875            w2if.SetScale(int(scale), int(scale))
1876        if settings.screenshot_transparent_background:
1877            w2if.SetInputBufferTypeToRGBA()
1878        w2if.ReadFrontBufferOff()  # read from the back buffer
1879    w2if.Update()
1880
1881    if asarray:
1882        pd = w2if.GetOutput().GetPointData()
1883        npdata = utils.vtk2numpy(pd.GetArray("ImageScalars"))
1884        # npdata = npdata[:, [0, 1, 2]]  # remove alpha channel, issue #1199
1885        ydim, xdim, _ = w2if.GetOutput().GetDimensions()
1886        npdata = npdata.reshape([xdim, ydim, -1])
1887        npdata = np.flip(npdata, axis=0)
1888        return npdata ###########################
1889
1890    if filename.lower().endswith(".png"):
1891        writer = vtki.new("PNGWriter")
1892        writer.SetFileName(filename)
1893        writer.SetInputData(w2if.GetOutput())
1894        writer.Write()
1895    elif filename.lower().endswith(".jpg") or filename.lower().endswith(".jpeg"):
1896        writer = vtki.new("JPEGWriter")
1897        writer.SetFileName(filename)
1898        writer.SetInputData(w2if.GetOutput())
1899        writer.Write()
1900    else:  # add .png
1901        writer = vtki.new("PNGWriter")
1902        writer.SetFileName(filename + ".png")
1903        writer.SetInputData(w2if.GetOutput())
1904        writer.Write()
1905    return vedo.plotter_instance
1906
1907
1908def ask(*question, **kwarg) -> str:
1909    """
1910    Ask a question from command line. Return the answer as a string.
1911    See function `colors.printc()` for the description of the keyword options.
1912
1913    Arguments:
1914        options : (list)
1915            a python list of possible answers to choose from.
1916        default : (str)
1917            the default answer when just hitting return.
1918
1919    Example:
1920    ```python
1921    import vedo
1922    res = vedo.ask("Continue?", options=['Y','n'], default='Y', c='g')
1923    print(res)
1924    ```
1925    """
1926    kwarg.update({"end": " "})
1927    if "invert" not in kwarg:
1928        kwarg.update({"invert": True})
1929    if "box" in kwarg:
1930        kwarg.update({"box": ""})
1931
1932    options = kwarg.pop("options", [])
1933    default = kwarg.pop("default", "")
1934    if options:
1935        opt = "["
1936        for o in options:
1937            opt += o + "/"
1938        opt = opt[:-1] + "]"
1939        colors.printc(*question, opt, **kwarg)
1940    else:
1941        colors.printc(*question, **kwarg)
1942
1943    try:
1944        resp = input()
1945    except Exception:
1946        resp = ""
1947        return resp
1948
1949    if options:
1950        if resp not in options:
1951            if default and str(repr(resp)) == "''":
1952                return default
1953            colors.printc("Please choose one option in:", opt, italic=True, bold=False)
1954            kwarg["options"] = options
1955            return ask(*question, **kwarg)  # ask again
1956    return resp
1957
1958
1959##############################################################################################
1960class Video:
1961    """
1962    Generate a video from a rendering window.
1963    """
1964
1965    def __init__(self, name="movie.mp4", duration=None, fps=24, scale=1, backend="imageio"):
1966        """
1967        Class to generate a video from the specified rendering window.
1968        Program `ffmpeg` is used to create video from each generated frame.
1969
1970        Arguments:
1971            name : (Union[str, os.PathLike])
1972                name of the output file.
1973            duration : (float)
1974                set the total `duration` of the video and recalculates `fps` accordingly.
1975            fps : (int)
1976                set the number of frames per second.
1977            scale : (int)
1978                set the image magnification as an integer multiplicative factor.
1979            backend : (str)
1980                the backend engine to be used `['imageio', 'ffmpeg', 'cv']`
1981
1982        Examples:
1983            - [make_video.py](https://github.com/marcomusy/vedo/tree/master/examples/other/make_video.py)
1984
1985            ![](https://user-images.githubusercontent.com/32848391/50739007-2bfc2b80-11da-11e9-97e6-620a3541a6fa.jpg)
1986        """
1987        self.name = str(name)
1988        self.duration = duration
1989        self.backend = backend
1990        self.fps = float(fps)
1991        self.command = "ffmpeg -loglevel panic -y -r"
1992        self.options = "-b:v 8000k"
1993        self.scale = scale
1994
1995        self.frames = []
1996        self.tmp_dir = TemporaryDirectory()
1997        self.get_filename = lambda x: os.path.join(self.tmp_dir.name, x)
1998        colors.printc(":video:  Video file", self.name, "is open... ", c="m", end="")
1999
2000    def add_frame(self) -> "Video":
2001        """Add frame to current video."""
2002        fr = self.get_filename(str(len(self.frames)) + ".png")
2003        screenshot(fr, scale=self.scale)
2004        self.frames.append(fr)
2005        return self
2006
2007    def pause(self, pause=0) -> "Video":
2008        """Insert a `pause`, in seconds."""
2009        fr = self.frames[-1]
2010        n = int(self.fps * pause)
2011        for _ in range(n):
2012            fr2 = self.get_filename(str(len(self.frames)) + ".png")
2013            self.frames.append(fr2)
2014            os.system("cp -f %s %s" % (fr, fr2))
2015        return self
2016
2017    def action(self, elevation=(0, 80), azimuth=(0, 359), cameras=(), resetcam=False) -> "Video":
2018        """
2019        Automatic shooting of a static scene by specifying rotation and elevation ranges.
2020
2021        Arguments:
2022            elevation : list
2023                initial and final elevation angles
2024            azimuth_range : list
2025                initial and final azimuth angles
2026            cameras : list
2027                list of cameras to go through, each camera can be dictionary or a vtkCamera
2028        """
2029        if not self.duration:
2030            self.duration = 5
2031
2032        plt = vedo.plotter_instance
2033        if not plt:
2034            vedo.logger.error("No vedo plotter found, cannot make video.")
2035            return self
2036        n = int(self.fps * self.duration)
2037
2038        cams = []
2039        for cm in cameras:
2040            cams.append(utils.camera_from_dict(cm))
2041        nc = len(cams)
2042
2043        plt.show(resetcam=resetcam, interactive=False)
2044
2045        if nc:
2046            for i in range(n):
2047                plt.move_camera(cams, i / (n-1))
2048                plt.render()
2049                self.add_frame()
2050
2051        else:  ########################################
2052
2053            for i in range(n):
2054                plt.camera.Elevation((elevation[1] - elevation[0]) / n)
2055                plt.camera.Azimuth((azimuth[1] - azimuth[0]) / n)
2056                plt.render()
2057                self.add_frame()
2058
2059        return self
2060
2061    def close(self) -> None:
2062        """
2063        Render the video and write it to file.
2064        """
2065        if self.duration:
2066            self.fps = int(len(self.frames) / float(self.duration) + 0.5)
2067            colors.printc("recalculated fps:", self.fps, c="m", end="")
2068        else:
2069            self.fps = int(self.fps)
2070
2071        ########################################
2072        if self.backend == "ffmpeg":
2073            out = os.system(
2074                self.command
2075                + " "
2076                + str(self.fps)
2077                + " -i "
2078                + f"'{self.tmp_dir.name}'"
2079                + os.sep
2080                + "%01d.png "
2081                + self.options
2082                + " "
2083                + f"'{self.name}'"
2084            )
2085            if out:
2086                vedo.logger.error(f":noentry: backend {self.backend} returning error: {out}")
2087            else:
2088                colors.printc(f":save: saved to {self.name}", c="m")
2089
2090        ########################################
2091        elif "cv" in self.backend:
2092            try:
2093                import cv2
2094            except ImportError:
2095                vedo.logger.error("opencv is not installed")
2096                return
2097
2098            cap = cv2.VideoCapture(os.path.join(self.tmp_dir.name, "%1d.png"))
2099            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
2100            if vedo.plotter_instance:
2101                w, h = vedo.plotter_instance.window.GetSize()
2102                writer = cv2.VideoWriter(self.name, fourcc, self.fps, (w, h), True)
2103            else:
2104                vedo.logger.error("No vedo plotter found, cannot make video.")
2105                return
2106
2107            while True:
2108                ret, frame = cap.read()
2109                if not ret:
2110                    break
2111                writer.write(frame)
2112
2113            cap.release()
2114            writer.release()
2115
2116        ########################################
2117        elif "imageio" in self.backend:
2118            try:
2119                import imageio
2120            except ImportError:
2121                vedo.logger.error("Please install imageio with:\n pip install imageio[ffmpeg]")
2122                return
2123
2124            if self.name.endswith(".mp4"):
2125                writer = imageio.get_writer(self.name, fps=self.fps)
2126            elif self.name.endswith(".gif"):
2127                writer = imageio.get_writer(self.name, mode="I", duration=1 / self.fps)
2128            elif self.name.endswith(".webm"):
2129                writer = imageio.get_writer(self.name, format="webm", fps=self.fps)
2130            else:
2131                vedo.logger.error(f"Unknown format of {self.name}.")
2132                return
2133
2134            for f in utils.humansort(self.frames):
2135                image = imageio.v3.imread(f)
2136                try:
2137                    writer.append_data(image)
2138                except TypeError:
2139                    vedo.logger.error(f"Could not append data to video {self.name}")
2140                    vedo.logger.error("Please install imageio with: pip install imageio[ffmpeg]")
2141                    break
2142            try:
2143                writer.close()
2144                colors.printc(f"... saved as {self.name}", c="m")
2145            except:
2146                colors.printc(f":noentry: Could not save video {self.name}", c="r")
2147
2148        # finalize cleanup
2149        self.tmp_dir.cleanup()
2150
2151    def split_frames(self, output_dir="video_frames", prefix="frame_", format="png") -> None:
2152        """Split an existing video file into frames."""
2153        try:
2154            import imageio
2155        except ImportError:
2156            vedo.logger.error("\nPlease install imageio with:\n pip install imageio")
2157            return
2158
2159        # Create the output directory if it doesn't exist
2160        if not os.path.exists(output_dir):
2161            os.makedirs(output_dir)
2162
2163        # Create a reader object to read the video
2164        reader = imageio.get_reader(self.name)
2165
2166        # Loop through each frame of the video and save it as image
2167        print()
2168        for i, frame in utils.progressbar(
2169            enumerate(reader), title=f"writing {format} frames", c="m", width=20
2170        ):
2171            output_file = os.path.join(output_dir, f"{prefix}{str(i).zfill(5)}.{format}")
2172            imageio.imwrite(output_file, frame, format=format)

def load(inputobj: Union[list, str, os.PathLike], unpack=True, force=False) -> Any: View Source

177def load(inputobj: Union[list, str, os.PathLike], unpack=True, force=False) -> Any:
178    """
179    Load any vedo objects from file or from the web.
180
181    The output will depend on the file extension. See examples below.
182    Unzip is made on the fly, if file ends with `.gz`.
183    Can load an object directly from a URL address.
184
185    Arguments:
186        unpack : (bool)
187            unpack MultiBlockData into a flat list of objects.
188        force : (bool)
189            when downloading a file ignore any previous cached downloads and force a new one.
190
191    Example:
192        ```python
193        from vedo import dataurl, load, show
194        # Return a list of 2 meshes
195        g = load([dataurl+'250.vtk', dataurl+'270.vtk'])
196        show(g)
197        # Return a list of meshes by reading all files in a directory
198        # (if directory contains DICOM files then a Volume is returned)
199        g = load('mydicomdir/')
200        show(g)
201        ```
202    """
203    if isinstance(inputobj, list):
204        inputobj = [str(f) for f in inputobj]
205    else:
206        inputobj = str(inputobj)
207    
208    acts = []
209    if utils.is_sequence(inputobj):
210        flist = inputobj
211    elif isinstance(inputobj, str) and inputobj.startswith("https://"):
212        flist = [inputobj]
213    else:
214        flist = utils.humansort(glob.glob(inputobj))
215
216    for fod in flist:
217
218        if fod.startswith("https://"):
219            fod = download(fod, force=force, verbose=False)
220
221        if os.path.isfile(fod):  ### it's a file
222
223            if fod.endswith(".gz"):
224                fod = gunzip(fod)
225
226            a = _load_file(fod, unpack)
227            acts.append(a)
228
229        elif os.path.isdir(fod):  ### it's a directory or DICOM
230            flist = os.listdir(fod)
231            if ".dcm" in flist[0]:  ### it's DICOM
232                reader = vtki.new("DICOMImageReader")
233                reader.SetDirectoryName(fod)
234                reader.Update()
235                image = reader.GetOutput()
236                vol = Volume(image)
237                try:
238                    vol.metadata["PixelSpacing"] = reader.GetPixelSpacing()
239                    vol.metadata["Width"] = reader.GetWidth()
240                    vol.metadata["Height"] = reader.GetHeight()
241                    vol.metadata["PositionPatient"] = reader.GetImagePositionPatient()
242                    vol.metadata["OrientationPatient"] = reader.GetImageOrientationPatient()
243                    vol.metadata["BitsAllocated"] = reader.GetBitsAllocated()
244                    vol.metadata["PixelRepresentation"] = reader.GetPixelRepresentation()
245                    vol.metadata["NumberOfComponents"] = reader.GetNumberOfComponents()
246                    vol.metadata["TransferSyntaxUID"] = reader.GetTransferSyntaxUID()
247                    vol.metadata["RescaleSlope"] = reader.GetRescaleSlope()
248                    vol.metadata["RescaleOffset"] = reader.GetRescaleOffset()
249                    vol.metadata["PatientName"] = reader.GetPatientName()
250                    vol.metadata["StudyUID"] = reader.GetStudyUID()
251                    vol.metadata["StudyID"] = reader.GetStudyID()
252                    vol.metadata["GantryAngle"] = reader.GetGantryAngle()
253                except Exception as e:
254                    vedo.logger.warning(f"Cannot read DICOM metadata: {e}")
255                acts.append(vol)
256
257            else:  ### it's a normal directory
258                utils.humansort(flist)
259                for ifile in flist:
260                    a = _load_file(fod + "/" + ifile, unpack)
261                    acts.append(a)
262        else:
263            vedo.logger.error(f"in load(), cannot find {fod}")
264
265    if len(acts) == 1:
266        if "numpy" in str(type(acts[0])):
267            return acts[0]
268        if not acts[0]:
269            vedo.logger.error(f"in load(), cannot load {inputobj}")
270        return acts[0]
271
272    if len(acts) == 0:
273        vedo.logger.error(f"in load(), cannot load {inputobj}")
274        return None
275
276    else:
277        return acts

Load any vedo objects from file or from the web.

The output will depend on the file extension. See examples below. Unzip is made on the fly, if file ends with .gz. Can load an object directly from a URL address.

Arguments:

unpack : (bool) unpack MultiBlockData into a flat list of objects.
force : (bool) when downloading a file ignore any previous cached downloads and force a new one.

Example:

from vedo import dataurl, load, show
# Return a list of 2 meshes
g = load([dataurl+'250.vtk', dataurl+'270.vtk'])
show(g)
# Return a list of meshes by reading all files in a directory
# (if directory contains DICOM files then a Volume is returned)
g = load('mydicomdir/')
show(g)

def read(obj: Any, unpack=True, force=False) -> Any: View Source

1373def read(obj: Any, unpack=True, force=False) -> Any:
1374    """Read an object from file. Same as `load()`."""
1375    return load(obj, unpack, force)

Read an object from file. Same as load().

def download(url: str, force=False, verbose=True) -> str: View Source

466def download(url: str, force=False, verbose=True) -> str:
467    """
468    Retrieve a file from a URL, save it locally and return its path.
469    Use `force=True` to force a reload and discard cached copies.
470    """
471    if not url.startswith("https://"):
472        # assume it's a file so no need to download
473        return url
474    url = url.replace("www.dropbox", "dl.dropbox")
475
476    if "github.com" in url:
477        url = url.replace("/blob/", "/raw/")
478
479    basename = os.path.basename(url)
480
481    if "?" in basename:
482        basename = basename.split("?")[0]
483
484    home_directory = os.path.expanduser("~")
485    cachedir = os.path.join(home_directory, settings.cache_directory, "vedo")
486    fname = os.path.join(cachedir, basename)
487    # Create the directory if it does not exist
488    if not os.path.exists(cachedir):
489        os.makedirs(cachedir)
490
491    if not force and os.path.exists(fname):
492        if verbose:
493            colors.printc("reusing cached file:", fname)
494        return fname
495
496    try:
497        from urllib.request import urlopen, Request
498        req = Request(url, headers={"User-Agent": "Mozilla/5.0"})
499        if verbose:
500            colors.printc("reading", basename, "from", url.split("/")[2][:40], "...", end="")
501
502    except ImportError:
503        import urllib2
504        import contextlib
505        urlopen = lambda url_: contextlib.closing(urllib2.urlopen(url_))
506        req = url
507        if verbose:
508            colors.printc("reading", basename, "from", url.split("/")[2][:40], "...", end="")
509
510    with urlopen(req) as response, open(fname, "wb") as output:
511        output.write(response.read())
512
513    if verbose:
514        colors.printc(" done.")
515    return fname

Retrieve a file from a URL, save it locally and return its path. Use force=True to force a reload and discard cached copies.

def gunzip(filename: str) -> str: View Source

595def gunzip(filename: str) -> str:
596    """Unzip a `.gz` file to a temporary file and returns its path."""
597    if not filename.endswith(".gz"):
598        # colors.printc("gunzip() error: file must end with .gz", c='r')
599        return filename
600
601    import gzip
602
603    tmp_file = NamedTemporaryFile(delete=False)
604    tmp_file.name = os.path.join(
605        os.path.dirname(tmp_file.name), os.path.basename(filename).replace(".gz", "")
606    )
607    inF = gzip.open(filename, "rb")
608    with open(tmp_file.name, "wb") as outF:
609        outF.write(inF.read())
610    inF.close()
611    return tmp_file.name

Unzip a .gz file to a temporary file and returns its path.

def loadStructuredPoints(filename: Union[str, os.PathLike], as_points=True): View Source

630def loadStructuredPoints(filename: Union[str, os.PathLike], as_points=True):
631    """
632    Load and return a `vtkStructuredPoints` object from file.
633    
634    If `as_points` is True, return a `Points` object
635    instead of a `vtkStructuredPoints`.
636    """
637    filename = str(filename)
638    reader = vtki.new("StructuredPointsReader")
639    reader.SetFileName(filename)
640    reader.Update()
641    if as_points:
642        v2p = vtki.new("ImageToPoints")
643        v2p.SetInputData(reader.GetOutput())
644        v2p.Update()
645        pts = Points(v2p.GetOutput())
646        return pts
647    return reader.GetOutput()

Load and return a vtkStructuredPoints object from file.

If as_points is True, return a Points object instead of a vtkStructuredPoints.

def loadStructuredGrid(filename: Union[str, os.PathLike]): View Source

650def loadStructuredGrid(filename: Union[str, os.PathLike]):
651    """Load and return a `vtkStructuredGrid` object from file."""
652    filename = str(filename)
653    if filename.endswith(".vts"):
654        reader = vtki.new("XMLStructuredGridReader")
655    else:
656        reader = vtki.new("StructuredGridReader")
657    reader.SetFileName(filename)
658    reader.Update()
659    return reader.GetOutput()

Load and return a vtkStructuredGrid object from file.

def write(objct: Any, fileoutput: Union[str, os.PathLike], binary=True) -> Any: View Source

1180def write(objct: Any, fileoutput: Union[str, os.PathLike], binary=True) -> Any:
1181    """
1182    Write object to file. Same as `save()`.
1183
1184    Supported extensions are:
1185    
1186    - `vtk, vti, ply, obj, stl, byu, vtp, vti, mhd, xyz, xml, tif, png, bmp`
1187    """
1188    fileoutput = str(fileoutput)
1189
1190    ###############################
1191    if isinstance(objct, Assembly):
1192        dd = to_numpy(objct)
1193        sdict = {"objects": [dd]}
1194        np.save(fileoutput, sdict)
1195        return objct
1196    
1197    ###############################
1198    obj = objct.dataset
1199
1200    try:
1201        # check if obj is a Mesh.actor and has a transform
1202        M = objct.actor.GetMatrix()
1203        if M and not M.IsIdentity():
1204            obj = objct.apply_transform_from_actor()
1205            obj = objct.dataset
1206            vedo.logger.info(
1207                f"object '{objct.name}' "
1208                "was manually moved. Writing uses current position."
1209            )
1210    except:
1211        pass
1212
1213    fr = fileoutput.lower()
1214    if fr.endswith(".vtk"):
1215        writer = vtki.new("DataSetWriter")
1216    elif fr.endswith(".ply"):
1217        writer = vtki.new("PLYWriter")
1218        writer.AddComment("PLY file generated by vedo")
1219        lut = objct.mapper.GetLookupTable()
1220        if lut:
1221            pscal = obj.GetPointData().GetScalars()
1222            if not pscal:
1223                pscal = obj.GetCellData().GetScalars()
1224            if pscal and pscal.GetName():
1225                writer.SetArrayName(pscal.GetName())
1226            writer.SetLookupTable(lut)
1227    elif fr.endswith(".stl"):
1228        writer = vtki.new("STLWriter")
1229    elif fr.endswith(".vtp"):
1230        writer = vtki.new("XMLPolyDataWriter")
1231    elif fr.endswith(".vtu"):
1232        writer = vtki.new("XMLUnstructuredGridWriter")
1233    elif fr.endswith(".xyz"):
1234        writer = vtki.new("SimplePointsWriter")
1235    elif fr.endswith(".facet"):
1236        writer = vtki.new("FacetWriter")
1237    elif fr.endswith(".vti"):
1238        writer = vtki.new("XMLImageDataWriter")
1239    elif fr.endswith(".vtr"):
1240        writer = vtki.new("XMLRectilinearGridWriter")
1241    elif fr.endswith(".vtm"):
1242        g = vtki.new("MultiBlockDataGroupFilter")
1243        for ob in objct:
1244            try:
1245                g.AddInputData(ob)
1246            except TypeError:
1247                vedo.logger.warning("cannot save object of type", type(ob))
1248        g.Update()
1249        mb = g.GetOutputDataObject(0)
1250        wri = vtki.new("vtkXMLMultiBlockDataWriter")
1251        wri.SetInputData(mb)
1252        wri.SetFileName(fileoutput)
1253        wri.Write()
1254        return objct
1255    elif fr.endswith(".mhd"):
1256        writer = vtki.new("MetaImageWriter")
1257    elif fr.endswith(".nii"):
1258        writer = vtki.new("NIFTIImageWriter")
1259    elif fr.endswith(".png"):
1260        writer = vtki.new("PNGWriter")
1261    elif fr.endswith(".jpg"):
1262        writer = vtki.new("JPEGWriter")
1263    elif fr.endswith(".bmp"):
1264        writer = vtki.new("BMPWriter")
1265    elif fr.endswith(".tif") or fr.endswith(".tiff"):
1266        writer = vtki.new("TIFFWriter")
1267        writer.SetFileDimensionality(len(obj.GetDimensions()))
1268    elif fr.endswith(".obj"):
1269        with open(fileoutput, "w", encoding="UTF-8") as outF:
1270            outF.write("# OBJ file format with ext .obj\n")
1271            outF.write("# File generated by vedo\n")
1272
1273            for p in objct.vertices:
1274                outF.write("v {:.8g} {:.8g} {:.8g}\n".format(*p))
1275
1276            ptxt = objct.dataset.GetPointData().GetTCoords()
1277            if ptxt:
1278                ntxt = utils.vtk2numpy(ptxt)
1279                for vt in ntxt:
1280                    outF.write("vt " + str(vt[0]) + " " + str(vt[1]) + " 0.0\n")
1281
1282            if isinstance(objct, Mesh):
1283                for i, f in enumerate(objct.cells):
1284                    fs = ""
1285                    for fi in f:
1286                        if ptxt:
1287                            fs += f" {fi+1}/{fi+1}"
1288                        else:
1289                            fs += f" {fi+1}"
1290                    outF.write(f"f{fs}\n")
1291
1292                for l in objct.lines:
1293                    ls = ""
1294                    for li in l:
1295                        ls += str(li + 1) + " "
1296                    outF.write(f"l {ls}\n")
1297        return objct
1298
1299    elif fr.endswith(".off"):
1300        with open(fileoutput, "w", encoding="UTF-8") as outF:
1301            outF.write("OFF\n")
1302            outF.write(str(objct.npoints) + " " + str(objct.ncells) + " 0\n\n")
1303            for p in objct.vertices:
1304                outF.write(" ".join([str(i) for i in p]) + "\n")
1305            for c in objct.cells:
1306                outF.write(str(len(c)) + " " + " ".join([str(i) for i in c]) + "\n")
1307        return objct
1308
1309    elif fr.endswith(".xml"):  # write tetrahedral dolfin xml
1310        vertices = objct.vertices.astype(str)
1311        faces = np.array(objct.cells).astype(str)
1312        ncoords = vertices.shape[0]
1313        with open(fileoutput, "w", encoding="UTF-8") as outF:
1314            outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
1315            outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
1316
1317            if len(faces[0]) == 4:  # write tetrahedral mesh
1318                ntets = faces.shape[0]
1319                outF.write('  <mesh celltype="tetrahedron" dim="3">\n')
1320                outF.write('    <vertices size="' + str(ncoords) + '">\n')
1321                for i in range(ncoords):
1322                    x, y, z = vertices[i]
1323                    outF.write('      <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
1324                outF.write('    </vertices>\n')
1325                outF.write('    <cells size="' + str(ntets) + '">\n')
1326                for i in range(ntets):
1327                    v0, v1, v2, v3 = faces[i]
1328                    outF.write('     <tetrahedron index="'+str(i)
1329                               + '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
1330
1331            elif len(faces[0]) == 3:  # write triangle mesh
1332                ntri = faces.shape[0]
1333                outF.write('  <mesh celltype="triangle" dim="2">\n')
1334                outF.write('    <vertices size="' + str(ncoords) + '">\n')
1335                for i in range(ncoords):
1336                    x, y, _ = vertices[i]
1337                    outF.write('      <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
1338                outF.write('    </vertices>\n')
1339                outF.write('    <cells size="' + str(ntri) + '">\n')
1340                for i in range(ntri):
1341                    v0, v1, v2 = faces[i]
1342                    outF.write('     <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
1343
1344            outF.write("    </cells>\n")
1345            outF.write("  </mesh>\n")
1346            outF.write("</dolfin>\n")
1347        return objct
1348
1349    else:
1350        vedo.logger.error(f"Unknown format {fileoutput}, file not saved")
1351        return objct
1352
1353    try:
1354        if binary:
1355            writer.SetFileTypeToBinary()
1356        else:
1357            writer.SetFileTypeToASCII()
1358    except AttributeError:
1359        pass
1360
1361    try:
1362        writer.SetInputData(obj)
1363        writer.SetFileName(fileoutput)
1364        writer.Write()
1365    except:
1366        vedo.logger.error(f"could not save {fileoutput}")
1367    return objct

Write object to file. Same as save().

Supported extensions are:

vtk, vti, ply, obj, stl, byu, vtp, vti, mhd, xyz, xml, tif, png, bmp

def save(obj: Any, fileoutput='out.png', binary=True) -> Any: View Source

1369def save(obj: Any, fileoutput="out.png", binary=True) -> Any:
1370    """Save an object to file. Same as `write()`."""
1371    return write(obj, fileoutput, binary)

Save an object to file. Same as write().

def export_window( fileoutput: Union[str, os.PathLike], binary=False, plt=None) -> vedo.plotter.Plotter: View Source

1378def export_window(fileoutput: Union[str, os.PathLike], binary=False, plt=None) -> "vedo.Plotter":
1379    """
1380    Exporter which writes out the rendered scene into an HTML, X3D or Numpy file.
1381
1382    Example:
1383        - [export_x3d.py](https://github.com/marcomusy/vedo/tree/master/examples/other/export_x3d.py)
1384
1385        Check out the HTML generated webpage [here](https://vedo.embl.es/examples/embryo.html).
1386
1387        <img src='https://user-images.githubusercontent.com/32848391/57160341-c6ffbd80-6de8-11e9-95ff-7215ce642bc5.jpg' width="600"/>
1388
1389    .. note::
1390        the rendering window can also be exported to `numpy` file `scene.npz`
1391        by pressing `E` key at any moment during visualization.
1392    """
1393    fileoutput = str(fileoutput)
1394    if plt is None:
1395        plt = vedo.plotter_instance
1396
1397    fr = fileoutput.lower()
1398    ####################################################################
1399    if fr.endswith(".npy") or fr.endswith(".npz"):
1400        _export_npy(plt, fileoutput)
1401
1402    ####################################################################
1403    elif fr.endswith(".x3d"):
1404        # obj = plt.get_actors()
1405        # if plt.axes_instances:
1406        #     obj.append(plt.axes_instances[0])
1407
1408        # for a in obj:
1409        #     if isinstance(a, Assembly):
1410        #         plt.remove(a)
1411        #         plt.add(a.unpack())
1412
1413        plt.render()
1414
1415        exporter = vtki.new("X3DExporter")
1416        exporter.SetBinary(binary)
1417        exporter.FastestOff()
1418        exporter.SetInput(plt.window)
1419        exporter.SetFileName(fileoutput)
1420        # exporter.WriteToOutputStringOn()
1421        exporter.Update()
1422        exporter.Write()
1423
1424        wsize = plt.window.GetSize()
1425        x3d_html = _x3d_html_template.replace("~fileoutput", fileoutput)
1426        x3d_html = x3d_html.replace("~width",  str(wsize[0]))
1427        x3d_html = x3d_html.replace("~height", str(wsize[1]))
1428        with open(fileoutput.replace(".x3d", ".html"), "w", encoding="UTF-8") as outF:
1429            outF.write(x3d_html)
1430
1431    ####################################################################
1432    elif fr.endswith(".html"):
1433        savebk = vedo.notebook_backend
1434        vedo.notebook_backend = "k3d"
1435        vedo.settings.default_backend = "k3d"
1436        # acts = plt.get_actors()
1437        plt = vedo.backends.get_notebook_backend(plt.objects)
1438
1439        with open(fileoutput, "w", encoding="UTF-8") as fp:
1440            fp.write(plt.get_snapshot())
1441
1442        vedo.notebook_backend = savebk
1443        vedo.settings.default_backend = savebk
1444
1445    else:
1446        vedo.logger.error(f"export extension {fr.split('.')[-1]} is not supported")
1447
1448    return plt

Exporter which writes out the rendered scene into an HTML, X3D or Numpy file.

Example:

export_x3d.py

Check out the HTML generated webpage here.

the rendering window can also be exported to numpy file scene.npz by pressing E key at any moment during visualization.

def import_window(fileinput: Union[str, os.PathLike]) -> Optional[vedo.plotter.Plotter]: View Source

1728def import_window(fileinput: Union[str, os.PathLike]) -> Union["vedo.Plotter", None]:
1729    """
1730    Import a whole scene from a Numpy NPZ file.
1731
1732    Returns:
1733        `vedo.Plotter` instance
1734    """
1735    fileinput = str(fileinput)
1736
1737    if fileinput.endswith(".npy") or fileinput.endswith(".npz"):
1738        return _import_npy(fileinput)
1739    
1740    # elif ".obj" in fileinput.lower():
1741    #     meshes = load_obj(fileinput, mtl_file, texture_path)
1742    #     plt = vedo.Plotter()
1743    #     plt.add(meshes)
1744    #     return plt
1745
1746    # elif fileinput.endswith(".h5") or fileinput.endswith(".hdf5"):
1747    #     return _import_hdf5(fileinput) # in store/file_io_HDF5.py
1748
1749    return None

Import a whole scene from a Numpy NPZ file.

Returns:

vedo.Plotter instance

def load_obj( fileinput: Union[str, os.PathLike], mtl_file=None, texture_path=None) -> List[vedo.mesh.Mesh]: View Source

1752def load_obj(fileinput: Union[str, os.PathLike], mtl_file=None, texture_path=None) -> List[Mesh]:
1753    """
1754    Import a set of meshes from a OBJ wavefront file.
1755
1756    Arguments:
1757        mtl_file : (str)
1758            MTL file for OBJ wavefront files
1759        texture_path : (str)
1760            path of the texture files directory
1761
1762    Returns:
1763        `list(Mesh)`
1764    """
1765    fileinput = str(fileinput)
1766
1767    window = vtki.vtkRenderWindow()
1768    window.SetOffScreenRendering(1)
1769    renderer = vtki.vtkRenderer()
1770    window.AddRenderer(renderer)
1771
1772    importer = vtki.new("OBJImporter")
1773    importer.SetFileName(fileinput)
1774    if mtl_file is None:
1775        mtl_file = fileinput.replace(".obj", ".mtl").replace(".OBJ", ".MTL")
1776    if os.path.isfile(mtl_file):
1777        importer.SetFileNameMTL(mtl_file)
1778    if texture_path is None:
1779        texture_path = fileinput.replace(".obj", ".txt").replace(".OBJ", ".TXT")
1780    # since the texture_path may be a directory which contains textures
1781    if os.path.exists(texture_path):
1782        importer.SetTexturePath(texture_path)
1783    importer.SetRenderWindow(window)
1784    importer.Update()
1785
1786    actors = renderer.GetActors()
1787    actors.InitTraversal()
1788    objs = []
1789    for _ in range(actors.GetNumberOfItems()):
1790        vactor = actors.GetNextActor()
1791        msh = Mesh(vactor)
1792        msh.name = "OBJMesh"
1793        tx = vactor.GetTexture()
1794        if tx:
1795            msh.texture(tx)
1796        objs.append(msh)
1797    return objs

Import a set of meshes from a OBJ wavefront file.

Arguments:

mtl_file : (str) MTL file for OBJ wavefront files
texture_path : (str) path of the texture files directory

Returns:

list(Mesh)

def screenshot( filename='screenshot.png', scale=1, asarray=False) -> Union[vedo.plotter.Plotter, numpy.ndarray, NoneType]: View Source

1801def screenshot(filename="screenshot.png", scale=1, asarray=False) -> Union["vedo.Plotter", np.ndarray, None]:
1802    """
1803    Save a screenshot of the current rendering window.
1804
1805    Alternatively, press key `Shift-S` in the rendering window to save a screenshot.
1806    You can also use keyword `screenshot` in `show(..., screenshot="pic.png")`.
1807
1808    Arguments:
1809        scale : (int)
1810            Set image magnification as an integer multiplicative factor.
1811            E.g. setting a magnification of 2 produces an image twice as large,
1812            but 10x slower to generate.
1813        asarray : (bool)
1814            Return a numpy array of the image
1815    """
1816    filename = str(filename)
1817    # print("calling screenshot", filename, scale, asarray)
1818
1819    if not vedo.plotter_instance or not vedo.plotter_instance.window:
1820        # vedo.logger.error("in screenshot(), rendering window is not present, skip.")
1821        return vedo.plotter_instance  ##########
1822    
1823    if vedo.plotter_instance.renderer:
1824        vedo.plotter_instance.renderer.ResetCameraClippingRange()
1825
1826    if asarray and scale == 1 and not vedo.plotter_instance.offscreen:
1827        nx, ny = vedo.plotter_instance.window.GetSize()
1828        arr = vtki.vtkUnsignedCharArray()
1829        vedo.plotter_instance.window.GetRGBACharPixelData(0, 0, nx-1, ny-1, 0, arr)
1830        narr = vedo.vtk2numpy(arr).T[:3].T.reshape([ny, nx, 3])
1831        narr = np.flip(narr, axis=0)
1832        return narr  ##########
1833
1834    ###########################
1835    if filename.endswith(".pdf"):
1836        writer = vtki.new("GL2PSExporter")
1837        writer.SetRenderWindow(vedo.plotter_instance.window)
1838        writer.Write3DPropsAsRasterImageOff()
1839        writer.SilentOn()
1840        writer.SetSortToBSP()
1841        writer.SetFileFormatToPDF()
1842        writer.SetFilePrefix(filename.replace(".pdf", ""))
1843        writer.Write()
1844        return vedo.plotter_instance  ##########
1845
1846    elif filename.endswith(".svg"):
1847        writer = vtki.new("GL2PSExporter")
1848        writer.SetRenderWindow(vedo.plotter_instance.window)
1849        writer.Write3DPropsAsRasterImageOff()
1850        writer.SilentOn()
1851        writer.SetSortToBSP()
1852        writer.SetFileFormatToSVG()
1853        writer.SetFilePrefix(filename.replace(".svg", ""))
1854        writer.Write()
1855        return vedo.plotter_instance  ##########
1856
1857    elif filename.endswith(".eps"):
1858        writer = vtki.new("GL2PSExporter")
1859        writer.SetRenderWindow(vedo.plotter_instance.window)
1860        writer.Write3DPropsAsRasterImageOff()
1861        writer.SilentOn()
1862        writer.SetSortToBSP()
1863        writer.SetFileFormatToEPS()
1864        writer.SetFilePrefix(filename.replace(".eps", ""))
1865        writer.Write()
1866        return vedo.plotter_instance  ##########
1867
1868    if settings.screeshot_large_image:
1869        w2if = vtki.new("RenderLargeImage")
1870        w2if.SetInput(vedo.plotter_instance.renderer)
1871        w2if.SetMagnification(scale)
1872    else:
1873        w2if = vtki.new("WindowToImageFilter")
1874        w2if.SetInput(vedo.plotter_instance.window)
1875        if hasattr(w2if, "SetScale"):
1876            w2if.SetScale(int(scale), int(scale))
1877        if settings.screenshot_transparent_background:
1878            w2if.SetInputBufferTypeToRGBA()
1879        w2if.ReadFrontBufferOff()  # read from the back buffer
1880    w2if.Update()
1881
1882    if asarray:
1883        pd = w2if.GetOutput().GetPointData()
1884        npdata = utils.vtk2numpy(pd.GetArray("ImageScalars"))
1885        # npdata = npdata[:, [0, 1, 2]]  # remove alpha channel, issue #1199
1886        ydim, xdim, _ = w2if.GetOutput().GetDimensions()
1887        npdata = npdata.reshape([xdim, ydim, -1])
1888        npdata = np.flip(npdata, axis=0)
1889        return npdata ###########################
1890
1891    if filename.lower().endswith(".png"):
1892        writer = vtki.new("PNGWriter")
1893        writer.SetFileName(filename)
1894        writer.SetInputData(w2if.GetOutput())
1895        writer.Write()
1896    elif filename.lower().endswith(".jpg") or filename.lower().endswith(".jpeg"):
1897        writer = vtki.new("JPEGWriter")
1898        writer.SetFileName(filename)
1899        writer.SetInputData(w2if.GetOutput())
1900        writer.Write()
1901    else:  # add .png
1902        writer = vtki.new("PNGWriter")
1903        writer.SetFileName(filename + ".png")
1904        writer.SetInputData(w2if.GetOutput())
1905        writer.Write()
1906    return vedo.plotter_instance

Save a screenshot of the current rendering window.

Alternatively, press key Shift-S in the rendering window to save a screenshot. You can also use keyword screenshot in show(..., screenshot="pic.png").

Arguments:

scale : (int) Set image magnification as an integer multiplicative factor. E.g. setting a magnification of 2 produces an image twice as large, but 10x slower to generate.
asarray : (bool) Return a numpy array of the image

def ask(*question, **kwarg) -> str: View Source

1909def ask(*question, **kwarg) -> str:
1910    """
1911    Ask a question from command line. Return the answer as a string.
1912    See function `colors.printc()` for the description of the keyword options.
1913
1914    Arguments:
1915        options : (list)
1916            a python list of possible answers to choose from.
1917        default : (str)
1918            the default answer when just hitting return.
1919
1920    Example:
1921    ```python
1922    import vedo
1923    res = vedo.ask("Continue?", options=['Y','n'], default='Y', c='g')
1924    print(res)
1925    ```
1926    """
1927    kwarg.update({"end": " "})
1928    if "invert" not in kwarg:
1929        kwarg.update({"invert": True})
1930    if "box" in kwarg:
1931        kwarg.update({"box": ""})
1932
1933    options = kwarg.pop("options", [])
1934    default = kwarg.pop("default", "")
1935    if options:
1936        opt = "["
1937        for o in options:
1938            opt += o + "/"
1939        opt = opt[:-1] + "]"
1940        colors.printc(*question, opt, **kwarg)
1941    else:
1942        colors.printc(*question, **kwarg)
1943
1944    try:
1945        resp = input()
1946    except Exception:
1947        resp = ""
1948        return resp
1949
1950    if options:
1951        if resp not in options:
1952            if default and str(repr(resp)) == "''":
1953                return default
1954            colors.printc("Please choose one option in:", opt, italic=True, bold=False)
1955            kwarg["options"] = options
1956            return ask(*question, **kwarg)  # ask again
1957    return resp

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:

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

class Video: View Source

1961class Video:
1962    """
1963    Generate a video from a rendering window.
1964    """
1965
1966    def __init__(self, name="movie.mp4", duration=None, fps=24, scale=1, backend="imageio"):
1967        """
1968        Class to generate a video from the specified rendering window.
1969        Program `ffmpeg` is used to create video from each generated frame.
1970
1971        Arguments:
1972            name : (Union[str, os.PathLike])
1973                name of the output file.
1974            duration : (float)
1975                set the total `duration` of the video and recalculates `fps` accordingly.
1976            fps : (int)
1977                set the number of frames per second.
1978            scale : (int)
1979                set the image magnification as an integer multiplicative factor.
1980            backend : (str)
1981                the backend engine to be used `['imageio', 'ffmpeg', 'cv']`
1982
1983        Examples:
1984            - [make_video.py](https://github.com/marcomusy/vedo/tree/master/examples/other/make_video.py)
1985
1986            ![](https://user-images.githubusercontent.com/32848391/50739007-2bfc2b80-11da-11e9-97e6-620a3541a6fa.jpg)
1987        """
1988        self.name = str(name)
1989        self.duration = duration
1990        self.backend = backend
1991        self.fps = float(fps)
1992        self.command = "ffmpeg -loglevel panic -y -r"
1993        self.options = "-b:v 8000k"
1994        self.scale = scale
1995
1996        self.frames = []
1997        self.tmp_dir = TemporaryDirectory()
1998        self.get_filename = lambda x: os.path.join(self.tmp_dir.name, x)
1999        colors.printc(":video:  Video file", self.name, "is open... ", c="m", end="")
2000
2001    def add_frame(self) -> "Video":
2002        """Add frame to current video."""
2003        fr = self.get_filename(str(len(self.frames)) + ".png")
2004        screenshot(fr, scale=self.scale)
2005        self.frames.append(fr)
2006        return self
2007
2008    def pause(self, pause=0) -> "Video":
2009        """Insert a `pause`, in seconds."""
2010        fr = self.frames[-1]
2011        n = int(self.fps * pause)
2012        for _ in range(n):
2013            fr2 = self.get_filename(str(len(self.frames)) + ".png")
2014            self.frames.append(fr2)
2015            os.system("cp -f %s %s" % (fr, fr2))
2016        return self
2017
2018    def action(self, elevation=(0, 80), azimuth=(0, 359), cameras=(), resetcam=False) -> "Video":
2019        """
2020        Automatic shooting of a static scene by specifying rotation and elevation ranges.
2021
2022        Arguments:
2023            elevation : list
2024                initial and final elevation angles
2025            azimuth_range : list
2026                initial and final azimuth angles
2027            cameras : list
2028                list of cameras to go through, each camera can be dictionary or a vtkCamera
2029        """
2030        if not self.duration:
2031            self.duration = 5
2032
2033        plt = vedo.plotter_instance
2034        if not plt:
2035            vedo.logger.error("No vedo plotter found, cannot make video.")
2036            return self
2037        n = int(self.fps * self.duration)
2038
2039        cams = []
2040        for cm in cameras:
2041            cams.append(utils.camera_from_dict(cm))
2042        nc = len(cams)
2043
2044        plt.show(resetcam=resetcam, interactive=False)
2045
2046        if nc:
2047            for i in range(n):
2048                plt.move_camera(cams, i / (n-1))
2049                plt.render()
2050                self.add_frame()
2051
2052        else:  ########################################
2053
2054            for i in range(n):
2055                plt.camera.Elevation((elevation[1] - elevation[0]) / n)
2056                plt.camera.Azimuth((azimuth[1] - azimuth[0]) / n)
2057                plt.render()
2058                self.add_frame()
2059
2060        return self
2061
2062    def close(self) -> None:
2063        """
2064        Render the video and write it to file.
2065        """
2066        if self.duration:
2067            self.fps = int(len(self.frames) / float(self.duration) + 0.5)
2068            colors.printc("recalculated fps:", self.fps, c="m", end="")
2069        else:
2070            self.fps = int(self.fps)
2071
2072        ########################################
2073        if self.backend == "ffmpeg":
2074            out = os.system(
2075                self.command
2076                + " "
2077                + str(self.fps)
2078                + " -i "
2079                + f"'{self.tmp_dir.name}'"
2080                + os.sep
2081                + "%01d.png "
2082                + self.options
2083                + " "
2084                + f"'{self.name}'"
2085            )
2086            if out:
2087                vedo.logger.error(f":noentry: backend {self.backend} returning error: {out}")
2088            else:
2089                colors.printc(f":save: saved to {self.name}", c="m")
2090
2091        ########################################
2092        elif "cv" in self.backend:
2093            try:
2094                import cv2
2095            except ImportError:
2096                vedo.logger.error("opencv is not installed")
2097                return
2098
2099            cap = cv2.VideoCapture(os.path.join(self.tmp_dir.name, "%1d.png"))
2100            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
2101            if vedo.plotter_instance:
2102                w, h = vedo.plotter_instance.window.GetSize()
2103                writer = cv2.VideoWriter(self.name, fourcc, self.fps, (w, h), True)
2104            else:
2105                vedo.logger.error("No vedo plotter found, cannot make video.")
2106                return
2107
2108            while True:
2109                ret, frame = cap.read()
2110                if not ret:
2111                    break
2112                writer.write(frame)
2113
2114            cap.release()
2115            writer.release()
2116
2117        ########################################
2118        elif "imageio" in self.backend:
2119            try:
2120                import imageio
2121            except ImportError:
2122                vedo.logger.error("Please install imageio with:\n pip install imageio[ffmpeg]")
2123                return
2124
2125            if self.name.endswith(".mp4"):
2126                writer = imageio.get_writer(self.name, fps=self.fps)
2127            elif self.name.endswith(".gif"):
2128                writer = imageio.get_writer(self.name, mode="I", duration=1 / self.fps)
2129            elif self.name.endswith(".webm"):
2130                writer = imageio.get_writer(self.name, format="webm", fps=self.fps)
2131            else:
2132                vedo.logger.error(f"Unknown format of {self.name}.")
2133                return
2134
2135            for f in utils.humansort(self.frames):
2136                image = imageio.v3.imread(f)
2137                try:
2138                    writer.append_data(image)
2139                except TypeError:
2140                    vedo.logger.error(f"Could not append data to video {self.name}")
2141                    vedo.logger.error("Please install imageio with: pip install imageio[ffmpeg]")
2142                    break
2143            try:
2144                writer.close()
2145                colors.printc(f"... saved as {self.name}", c="m")
2146            except:
2147                colors.printc(f":noentry: Could not save video {self.name}", c="r")
2148
2149        # finalize cleanup
2150        self.tmp_dir.cleanup()
2151
2152    def split_frames(self, output_dir="video_frames", prefix="frame_", format="png") -> None:
2153        """Split an existing video file into frames."""
2154        try:
2155            import imageio
2156        except ImportError:
2157            vedo.logger.error("\nPlease install imageio with:\n pip install imageio")
2158            return
2159
2160        # Create the output directory if it doesn't exist
2161        if not os.path.exists(output_dir):
2162            os.makedirs(output_dir)
2163
2164        # Create a reader object to read the video
2165        reader = imageio.get_reader(self.name)
2166
2167        # Loop through each frame of the video and save it as image
2168        print()
2169        for i, frame in utils.progressbar(
2170            enumerate(reader), title=f"writing {format} frames", c="m", width=20
2171        ):
2172            output_file = os.path.join(output_dir, f"{prefix}{str(i).zfill(5)}.{format}")
2173            imageio.imwrite(output_file, frame, format=format)

Generate a video from a rendering window.

Video(name='movie.mp4', duration=None, fps=24, scale=1, backend='imageio') View Source

1966    def __init__(self, name="movie.mp4", duration=None, fps=24, scale=1, backend="imageio"):
1967        """
1968        Class to generate a video from the specified rendering window.
1969        Program `ffmpeg` is used to create video from each generated frame.
1970
1971        Arguments:
1972            name : (Union[str, os.PathLike])
1973                name of the output file.
1974            duration : (float)
1975                set the total `duration` of the video and recalculates `fps` accordingly.
1976            fps : (int)
1977                set the number of frames per second.
1978            scale : (int)
1979                set the image magnification as an integer multiplicative factor.
1980            backend : (str)
1981                the backend engine to be used `['imageio', 'ffmpeg', 'cv']`
1982
1983        Examples:
1984            - [make_video.py](https://github.com/marcomusy/vedo/tree/master/examples/other/make_video.py)
1985
1986            ![](https://user-images.githubusercontent.com/32848391/50739007-2bfc2b80-11da-11e9-97e6-620a3541a6fa.jpg)
1987        """
1988        self.name = str(name)
1989        self.duration = duration
1990        self.backend = backend
1991        self.fps = float(fps)
1992        self.command = "ffmpeg -loglevel panic -y -r"
1993        self.options = "-b:v 8000k"
1994        self.scale = scale
1995
1996        self.frames = []
1997        self.tmp_dir = TemporaryDirectory()
1998        self.get_filename = lambda x: os.path.join(self.tmp_dir.name, x)
1999        colors.printc(":video:  Video file", self.name, "is open... ", c="m", end="")

Class to generate a video from the specified rendering window. Program ffmpeg is used to create video from each generated frame.

Arguments:

name : (Union[str, os.PathLike]) name of the output file.
duration : (float) set the total duration of the video and recalculates fps accordingly.
fps : (int) set the number of frames per second.
scale : (int) set the image magnification as an integer multiplicative factor.
backend : (str) the backend engine to be used ['imageio', 'ffmpeg', 'cv']

Examples:

make_video.py

def add_frame(self) -> Video: View Source

2001    def add_frame(self) -> "Video":
2002        """Add frame to current video."""
2003        fr = self.get_filename(str(len(self.frames)) + ".png")
2004        screenshot(fr, scale=self.scale)
2005        self.frames.append(fr)
2006        return self

Add frame to current video.

def pause(self, pause=0) -> Video: View Source

2008    def pause(self, pause=0) -> "Video":
2009        """Insert a `pause`, in seconds."""
2010        fr = self.frames[-1]
2011        n = int(self.fps * pause)
2012        for _ in range(n):
2013            fr2 = self.get_filename(str(len(self.frames)) + ".png")
2014            self.frames.append(fr2)
2015            os.system("cp -f %s %s" % (fr, fr2))
2016        return self

Insert a pause, in seconds.

def action( self, elevation=(0, 80), azimuth=(0, 359), cameras=(), resetcam=False) -> Video: View Source

2018    def action(self, elevation=(0, 80), azimuth=(0, 359), cameras=(), resetcam=False) -> "Video":
2019        """
2020        Automatic shooting of a static scene by specifying rotation and elevation ranges.
2021
2022        Arguments:
2023            elevation : list
2024                initial and final elevation angles
2025            azimuth_range : list
2026                initial and final azimuth angles
2027            cameras : list
2028                list of cameras to go through, each camera can be dictionary or a vtkCamera
2029        """
2030        if not self.duration:
2031            self.duration = 5
2032
2033        plt = vedo.plotter_instance
2034        if not plt:
2035            vedo.logger.error("No vedo plotter found, cannot make video.")
2036            return self
2037        n = int(self.fps * self.duration)
2038
2039        cams = []
2040        for cm in cameras:
2041            cams.append(utils.camera_from_dict(cm))
2042        nc = len(cams)
2043
2044        plt.show(resetcam=resetcam, interactive=False)
2045
2046        if nc:
2047            for i in range(n):
2048                plt.move_camera(cams, i / (n-1))
2049                plt.render()
2050                self.add_frame()
2051
2052        else:  ########################################
2053
2054            for i in range(n):
2055                plt.camera.Elevation((elevation[1] - elevation[0]) / n)
2056                plt.camera.Azimuth((azimuth[1] - azimuth[0]) / n)
2057                plt.render()
2058                self.add_frame()
2059
2060        return self

Automatic shooting of a static scene by specifying rotation and elevation ranges.

Arguments:

elevation : list initial and final elevation angles
azimuth_range : list initial and final azimuth angles
cameras : list list of cameras to go through, each camera can be dictionary or a vtkCamera

def close(self) -> None: View Source

2062    def close(self) -> None:
2063        """
2064        Render the video and write it to file.
2065        """
2066        if self.duration:
2067            self.fps = int(len(self.frames) / float(self.duration) + 0.5)
2068            colors.printc("recalculated fps:", self.fps, c="m", end="")
2069        else:
2070            self.fps = int(self.fps)
2071
2072        ########################################
2073        if self.backend == "ffmpeg":
2074            out = os.system(
2075                self.command
2076                + " "
2077                + str(self.fps)
2078                + " -i "
2079                + f"'{self.tmp_dir.name}'"
2080                + os.sep
2081                + "%01d.png "
2082                + self.options
2083                + " "
2084                + f"'{self.name}'"
2085            )
2086            if out:
2087                vedo.logger.error(f":noentry: backend {self.backend} returning error: {out}")
2088            else:
2089                colors.printc(f":save: saved to {self.name}", c="m")
2090
2091        ########################################
2092        elif "cv" in self.backend:
2093            try:
2094                import cv2
2095            except ImportError:
2096                vedo.logger.error("opencv is not installed")
2097                return
2098
2099            cap = cv2.VideoCapture(os.path.join(self.tmp_dir.name, "%1d.png"))
2100            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
2101            if vedo.plotter_instance:
2102                w, h = vedo.plotter_instance.window.GetSize()
2103                writer = cv2.VideoWriter(self.name, fourcc, self.fps, (w, h), True)
2104            else:
2105                vedo.logger.error("No vedo plotter found, cannot make video.")
2106                return
2107
2108            while True:
2109                ret, frame = cap.read()
2110                if not ret:
2111                    break
2112                writer.write(frame)
2113
2114            cap.release()
2115            writer.release()
2116
2117        ########################################
2118        elif "imageio" in self.backend:
2119            try:
2120                import imageio
2121            except ImportError:
2122                vedo.logger.error("Please install imageio with:\n pip install imageio[ffmpeg]")
2123                return
2124
2125            if self.name.endswith(".mp4"):
2126                writer = imageio.get_writer(self.name, fps=self.fps)
2127            elif self.name.endswith(".gif"):
2128                writer = imageio.get_writer(self.name, mode="I", duration=1 / self.fps)
2129            elif self.name.endswith(".webm"):
2130                writer = imageio.get_writer(self.name, format="webm", fps=self.fps)
2131            else:
2132                vedo.logger.error(f"Unknown format of {self.name}.")
2133                return
2134
2135            for f in utils.humansort(self.frames):
2136                image = imageio.v3.imread(f)
2137                try:
2138                    writer.append_data(image)
2139                except TypeError:
2140                    vedo.logger.error(f"Could not append data to video {self.name}")
2141                    vedo.logger.error("Please install imageio with: pip install imageio[ffmpeg]")
2142                    break
2143            try:
2144                writer.close()
2145                colors.printc(f"... saved as {self.name}", c="m")
2146            except:
2147                colors.printc(f":noentry: Could not save video {self.name}", c="r")
2148
2149        # finalize cleanup
2150        self.tmp_dir.cleanup()

Render the video and write it to file.

def split_frames(self, output_dir='video_frames', prefix='frame_', format='png') -> None: View Source

2152    def split_frames(self, output_dir="video_frames", prefix="frame_", format="png") -> None:
2153        """Split an existing video file into frames."""
2154        try:
2155            import imageio
2156        except ImportError:
2157            vedo.logger.error("\nPlease install imageio with:\n pip install imageio")
2158            return
2159
2160        # Create the output directory if it doesn't exist
2161        if not os.path.exists(output_dir):
2162            os.makedirs(output_dir)
2163
2164        # Create a reader object to read the video
2165        reader = imageio.get_reader(self.name)
2166
2167        # Loop through each frame of the video and save it as image
2168        print()
2169        for i, frame in utils.progressbar(
2170            enumerate(reader), title=f"writing {format} frames", c="m", width=20
2171        ):
2172            output_file = os.path.join(output_dir, f"{prefix}{str(i).zfill(5)}.{format}")
2173            imageio.imwrite(output_file, frame, format=format)

Split an existing video file into frames.