def save_to_png(image_file_name, mesh_list):
    import pyvista as pv

    pv.start_xvfb()
    plotter = pv.Plotter(off_screen=True, shape=(1,1))

    for m in mesh_list:
        plotter.add_mesh(m, scalars = "spins_rgba", rgb = True, specular=0.7, ambient=0.4, specular_power=5, smooth_shading=True, show_scalar_bar=False, show_edges=False, metallic=True )

    plotter.set_background("white")
    plotter.add_axes(color="black", line_width=6)

    plotter.show(screenshot=image_file_name + ".png")
    def render_to_png(self, png_path ):
        pv.start_xvfb()
        plotter = pv.Plotter(off_screen=True, shape=(1,1))
        self.set_camera(plotter)

        for m, args in self.meshlist:
            try:
                plotter.add_mesh(m, **args)
            except Exception as e:
                print(f"Could not add_mesh {m}")
                print(e)

        plotter.set_background("white")
        plotter.add_axes(color="black", line_width=6)
        plotter.show(screenshot= png_path + ".png")
def plot_color_sphere(image_file_name, spin_to_rgba_func):
    import pyvista as pv

    sphere = pv.Sphere(radius=1.0, start_theta=180, end_theta = 90, phi_resolution=60, theta_resolution=60)

    sphere["spins_rgba"] = spin_to_rgba_func(sphere.points)

    pv.start_xvfb()
    plotter = pv.Plotter( off_screen=True, shape=(1,1), lighting=None)
    light = pv.Light(light_type='headlight')
    # these don't do anything for a headlight:
    light.position = (1, 2, 3)
    light.focal_point = (4, 5, 6)
    plotter.add_light(light)
    plotter.add_mesh(sphere, scalars="spins_rgba", specular=0.7, ambient=0.4, specular_power=5, rgb=True, smooth_shading=True)
    plotter.set_background("white")
    plotter.show(screenshot=image_file_name + ".png")
Exemple #4
0
import dolfinx.io
import dolfinx.plot
import numpy as np
import ufl
from mpi4py import MPI

try:
    import pyvista
except ModuleNotFoundError:
    print("pyvista is required for this demo")
    exit(0)

# If environment variable PYVISTA_OFF_SCREEN is set to true save a png
# otherwise create interactive plot
if pyvista.OFF_SCREEN:
    pyvista.start_xvfb(wait=0.1)

# Set some global options for all plots
transparent = False
figsize = 800
pyvista.rcParams["background"] = [0.5, 0.5, 0.5]

# Plotting a 3D dolfinx.Function with pyvista
# ===========================================


# Interpolate a simple scalar function in 3D
def int_u(x):
    return x[0] + 3 * x[1] + 5 * x[2]

Exemple #5
0
from dolfinx import (Function, FunctionSpace, NewtonSolver, UnitSquareMesh,
                     log, plot)
from dolfinx.cpp.mesh import CellType
from dolfinx.fem import NonlinearProblem
from dolfinx.io import XDMFFile
from mpi4py import MPI
from petsc4py import PETSc
from ufl import (FiniteElement, TestFunctions, diff, dx, grad, inner, split,
                 variable)

try:
    import pyvista as pv
    import pyvistaqt as pvqt
    have_pyvista = True
    if pv.OFF_SCREEN:
        pv.start_xvfb(wait=0.5)

except ModuleNotFoundError:
    print("pyvista is required to visualise the solution")
    have_pyvista = False

# Save all logging to file
log.set_output_file("log.txt")

#
# Next, various model parameters are defined::

# Model parameters
lmbda = 1.0e-02  # surface parameter
dt = 5.0e-06  # time step
theta = 0.5  # time stepping family, e.g. theta=1 -> backward Euler, theta=0.5 -> Crank-Nicolson
from dolfinx import (Form, Function, FunctionSpace, NewtonSolver,
                     UnitSquareMesh, fem, log, plot)
from dolfinx.cpp.mesh import CellType
from dolfinx.fem.assemble import assemble_matrix, assemble_vector
from dolfinx.io import XDMFFile
from mpi4py import MPI
from petsc4py import PETSc
from ufl import (FiniteElement, TestFunctions, TrialFunction, derivative, diff,
                 dx, grad, inner, split, variable)

try:
    import pyvista as pv
    import pyvistaqt as pvqt
    have_pyvista = True
    if pv.OFF_SCREEN:
        pv.start_xvfb(wait=0)

except ModuleNotFoundError:
    print("pyvista is required to visualise the solution")
    have_pyvista = False

# Save all logging to file
log.set_output_file("log.txt")

# .. index::
#    single: NonlinearProblem; (in Cahn-Hilliard demo)
#
# A class which will represent the Cahn-Hilliard in an abstract from for
# use in the Newton solver is now defined. It is a subclass of
# :py:class:`NonlinearProblem <dolfinx.cpp.NonlinearProblem>`.::
Exemple #7
0
time between model outputs, and output file
"""
import sys
import os

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
import cv2
import pyvista as pv

from tqdm import tqdm

from riftinversion import vtk_plot as vp

pv.start_xvfb()

directory = sys.argv[1]
time = float(sys.argv[2])
model_step = float(sys.argv[3])

nsteps = int(time/model_step)

timesteps = np.arange(0,nsteps,1)

files = vp.get_pvtu(directory,timesteps)

image_dir = 'images/'
os.makedirs(image_dir,exist_ok=True)

colors=['#99CCCC','#996633','#990000','#339966']