Updating scalar bar's range and mesh's colors

[Oguitton]

Hi,

Is it possible to modify colors of a mesh dynamically according to the scalar's bar ?
I want to choose the limit of the scalar bar and that in return the mesh update the color.
Like if I have many mesh on a vue, the scalars bar range would be the max and the min of the entire mesh. But if I want to choose the range of the color, can I do it ? For examples, the initial range would be from 10 to 4000. But this range would saturated on the small value like 10, 20 and 50 for example. So I want to update the scalar bar range and the color of meshs so I can see the difference between 10,20 and 50, for example the new range could be [10, 100]. Obviously, it will be saturated on the high value, but it is not a problem if it is reversible. Can it be dynamic in the pyvista vue ?
I find the way to change the range on the scalar bar but it doesnot match the mesh after.

Thanks for your help !

[jourdain]

Yes, you just need to code it that way. It could be easier for us if you share a small subset of what you are doing so we can point you to what you are missing.

[Oguitton]

Yes sorry ! I would like to control the range with a RangeSlider like this :

with layout.toolbar:
        vuetify.VSpacer()  
        
        vuetify.VRangeSlider(
            thumb_size=16,
            thumb_label=True,
            label="Echelle",
            v_model=("threshold_range", [0, 1]),  
            min=('0',),
            max=('10',),
            dense=True,
            hide_details=True,
            style="max-width: 400px",
        )

And in the v-model, I would like to put a small function with somenthing like that :

def update range(threshold_range, **kwargs):
   mesh_add.mapper.scalar_range = threshold_range 
   mesh_add.mapper.scalar_visibility = True 
   #add something to update the mesh's colors#

Thanks

[jourdain]

Can you share some code on how you setup your viz and scalar bar?

Depending on how PyVista setup the LUT usage, you might be able to just the change range on the LUT...

[Oguitton]

Yes so there is the entire code :

from trame.app import get_server
from trame.ui.vuetify import SinglePageLayout
from trame.ui.vuetify import SinglePageWithDrawerLayout
from trame.widgets import vtk, vuetify, trame
import numpy as np

import pyvista as pv
from pyvista.trame.ui import plotter_ui
from pv_utils import pvCoverageAlpha

import pyproj 
import elevation

from vtkmodules.vtkCommonDataModel import vtkDataObject,vtkUnstructuredGrid, vtkCellArray
from vtkmodules.vtkFiltersCore import vtkContourFilter, vtkThreshold
from vtkmodules.vtkIOXML import vtkXMLUnstructuredGridReader
from vtkmodules.vtkRenderingAnnotation import vtkCubeAxesActor

from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkDataSetMapper,
    vtkRenderer,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
)
# Required for interactor initialization
from vtkmodules.vtkInteractionStyle import vtkInteractorStyleSwitch  # noqa

# Required for rendering initialization, not necessary for
# local rendering, but doesn't hurt to include it
import vtkmodules.vtkRenderingOpenGL2  # noqa

from vtkmodules.vtkCommonCore import vtkPoints, vtkIdList
from vtkmodules.numpy_interface.dataset_adapter import numpyTovtkDataArray as np2da
from vtkmodules.util import vtkConstants


from os import listdir #pour lire les fichiers dans /vtk_files
from os.path import isfile, join
# -----------------------------------------------------------------------------
# VTK pipeline
# -----------------------------------------------------------------------------

renderer = vtkRenderer()
renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)

renderWindowInteractor = vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
# -----------------------------------------------------------------------------
# Trame initialization
# -----------------------------------------------------------------------------

pv.OFF_SCREEN = True

server = get_server()
state, ctrl = server.state, server.controller

state.trame__title = "Site"
ctrl.on_server_ready.add(ctrl.view_update)
# -----------------------------------------------------------------------------
# Init datafiles and topo files + mesh creation + init tab de noms, coverage etc
# -----------------------------------------------------------------------------

#--------- Lecture des fichiers vtk + topo

#obj tab pour stocker les noms de fichiers + noms des mesh

file_tot=['vtk_files/Larzac_Jasse_P02_2m_071010_DefaultInversion_shift.vtk']
topofile = ['topo/Larzac_Jasse_P02_topo.txt'] 
 
# fichiers_data = [f for f in listdir("./vtk_files") if isfile(join("./vtk_files", f))]
# fichiers_topo = [f for f in listdir("./topo") if isfile(join("./topo", f))]

# for i in range(len(fichiers_data)):
    # file_tot.append(("vtk_files/"+ fichiers_data[i]))

# for i in range(len(fichiers_topo)):  
    # topofile.append(("topo/"+fichiers_topo[i]))

# print(file_tot)
# print(topofile)

#file_tot = ['vtk_files/ert1_DefaultInversion_shift.vtk','vtk_files/ert2_DefaultInversion_shift.vtk','vtk_files/ert3_DefaultInversion_shift.vtk','vtk_files/ert4_DefaultInversion_shift.vtk']
#topofile = ['topo/LarzacJasseERT_topo.txt']


#--------- Init des differents tab ---------

state.name_mesh = []
actor = []
C = []
state.visibilityList =[]

#===Coordonnees GPS ===
utm_east = []
utm_north = []
gps_1 = []
gps_2 = []
gps_3 = []
gps_4 = []   

#=== Noms des mesh pour les checkbox ===
for k in range(len(file_tot)):
    temp = file_tot[k]
    # print(temp)
    temp = temp[10:]
    # print(temp)
    state.name_mesh.append(temp)
    

#=== crea des mesh ===
mesh = pv.read(file_tot)
taille =len(mesh)
print(taille)

#=== appli de coverage sur les fichiers entrees + init tab d'etat des checkbox ===
for j in range(len(mesh)):
    C.append(pvCoverageAlpha(mesh[j]))
    state.visibilityList.append('True')
    

# -----------------------------------------------------------------------------
# Plotting init
# -----------------------------------------------------------------------------

pl = pv.Plotter(window_size=(800, 600))
pl.set_background('lightgrey')
grid = pl.show_bounds(
    grid='front',
    location='outer',
    all_edges=True,
    xlabel="Easting UTM 31N (m)",
    ylabel="Northing UTM 31N (m)",
    zlabel="Elevation (m)",
    color='black',
    fmt='%3i'
)
renderer.AddActor(grid)
# pl.add_ruler(label_color='black',tick_color='black')


mesh_actor = None

# -----------------------------------------------------------------------------
# Fonctions diverses
# -----------------------------------------------------------------------------
 

#=== Traitements coordo GPS === 

#lecture dans le fichier topo
def gps_coordonnee():
            
    for j in range(len(topofile)):
        # Ouvrir le fichier en lecture seule
        file = open(topofile[j], "r")
        # utiliser readlines pour lire toutes les lignes du fichier
        # La variable "lignes" est une liste contenant toutes les lignes du fichier
        lines = file.readlines()
        # fermez le fichier après avoir lu les lignes
        file.close()

        #decoupe la premiere ligne
        first = lines[0].split()

        #decoupe de la derniere ligne
        num_end = len(lines)
        #print(num_end)
        end  = lines[num_end-1].split()
        #recuperation des coordonnees east et north
        # print(first[1])
        utm_east.insert(j,float(first[1]))
        utm_north.insert(j,float(first[2]))

        utm_east.insert(j,float(end[1]))
        utm_north.insert(j,float(end[2]))
    # print(utm_east)
    # print(utm_north)
    gps_1.insert(1,float(min(utm_east)))
    gps_1.insert(2,float(max(utm_north)))
    gps_2.insert(1,float(max(utm_east)))
    gps_2.insert(2,float(max(utm_north)))
    gps_3.insert(1,float(min(utm_east)))
    gps_3.insert(2,float(min(utm_north)))
    gps_4.insert(1,float(max(utm_east)))
    gps_4.insert(2,float(min(utm_north)))
    # print(gps_1)
    # print(gps_2)
    # print(gps_3)
    # print(gps_4)
    
#-------- tableaux de couple de valeurs pour les coordo utm et log lat ------
coordo_utm = [ gps_1,
               gps_2,
               gps_3,
               gps_4]
               
coordo_lonlat = [ gps_1,
               gps_2,
               gps_3,
               gps_4]

P = pyproj.Proj(proj='utm', zone=31, ellps='WGS84', preserve_units=True)

#fonction de transfert utm -> longlat 

def to_lat_long(coordo_utm, coordo_lonlat):
#creation d'un objet projet 
    
    print('utm')
    print(coordo_utm)
    for i in[0,1,2,3] : #boucle bornée car tjrs 4 coordonnees, 4 points 
        print(coordo_utm[i])
        (lon, lat )= P(coordo_utm[i][0], coordo_utm[i][1], inverse=True)
        coordo_lonlat[i][0]=lon
        coordo_lonlat[i][1]=lat
        print(coordo_lonlat[i][0], coordo_lonlat[i][1])
    
#fonction import MNT avec bopen.elevation  
def importation(coordo_lonlat):  
    # clip the SRTM1 30m DEM of Rome and save it to Rome-DEM.tif
    # elevation.clip(bounds=(coordo_lonlat[0][0], coordo_lonlat[0][1], coordo_lonlat[1][0], coordo_lonlat[1][1]), output='Rome-DEM.tif')
    elevation.clip(bounds=(12.35, 41.8, 12.65, 42), output='Rome-DEM.tif')
    # clean up stale temporary files and fix the cache in the event of a server error
    elevation.clean()

#=== Gestion des mesh ===

#creation des mesh
def create_mesh(actor):

    global pl, mesh_actor
    my_colormap = 'Spectral_r'
    size = 50
    Startpos = 5
    # my_colormap = 'cividis'
    if mesh_actor is not None:
        pl.remove_actor(mesh_actor)
    else:
        for i in range(len(mesh)):
            mesh_add = pl.add_mesh(mesh[i],scalars='Resistivity',cmap=my_colormap,
                    opacity=C[i],use_transparency=True)
            # mesh_add.mapper.scalar_range = [0, 10]  # Plage des valeurs scalaires à afficher dans la légende
            # mesh_add.mapper.scalar_visibility = True  # Afficher les valeurs scalaires dans la légende
            
            # print(mesh_add)
            actor.append(mesh_add)
            # print(actor[i])
        
    pl.reset_camera()

#Classe show hide
class SetVisibilityCallback:
    """Helper callback to keep a reference to the actor being modified."""

    def __init__(self, actor):
        self.actor = actor

    def __call__(self, state):
        self.actor.SetVisibility(state)

#Fonction show/hide        
def remove_profil(num,flag):
    actor[num].SetVisibility(flag)
    ctrl.view_update()

# fonction appelee dans la creation des checkboxes : 
#mettre à jour l'etat des box + hide/show avec la fonction remove_profil
def update_visibility(index, visibility):
    state.visibilityList[index] = visibility
    state.dirty("visibilityList")
    print(f"Toggle {index} to {visibility}")
    remove_profil(index,visibility)

#---------------------------------
# GUI
# --------------------------------
@state.change("threshold_range")
def update_range(threshold_range, **kwargs):
    print('ola')
    # vtk_filter.SetLowerThreshold(threshold_range[0])
    # vtk_filter.SetUpperThreshold(threshold_range[1])
    # ctrl.threshold_update()



# -----------------------------------------------------------------------------
# Page web + toolbar init /GUI
# -----------------------------------------------------------------------------


with SinglePageWithDrawerLayout(server) as layout:
    
    layout.icon.click = ctrl.view_reset_camera
    layout.title.set_text(state.trame__title)
    create_mesh(actor)
    # print('lancement de gsp coordo')
    # gps_coordonnee()
    # print(coordo_utm)
    # print('lancement de utm -> long lat')
    # to_lat_long(coordo_utm, coordo_lonlat)
    # print(coordo_lonlat)
    # # print('lancement de limportation')
    # # importation(coordo_lonlat)
    # # print('importation ok')
    # # print(actor)
    print(state.visibilityList)
    # for i in range(len(mesh)):
        # print (mesh[i])
    
    with layout.toolbar:
        vuetify.VSpacer()  
        # barre vertical de choix d'interval de valeurs 
        vuetify.VRangeSlider(
            thumb_size=16,
            thumb_label=True,
            label="Echelle",
            v_model=("threshold_range", [0, 1]),  #fonction qui fait appel a l'echelle de resistivity
            min=('0',),
            max=('10',),
            dense=True,
            hide_details=True,
            style="max-width: 400px",
        )
        # vuetify.VDivider(vertical=True, classes="mx-2")
        # standard_buttons()
         
    with layout.drawer:
        vuetify.VSpacer()
        # vuetify.VDivider(classes="mb-2")
        # for i in range(len(state.name_mesh)):
            # pipeline_widget(i)
            # print('pipeline widget')
            # print(i)
            # mesh_card(i)
            # print('mesh_card')
            
        with vuetify.VCol():
                vuetify.VCheckbox(
                    v_for="v, i in visibilityList",
                    key="i",
                    label=("name_mesh[i]",),
                    v_model=("visibilityList[i]",),
                    change=(update_visibility, "[i, $event]"),
                )
        
    with layout.content:
            with vuetify.VContainer(
                fluid=True,
                classes="pa-0 fill-height",
            ):
                # Use PyVista UI template for Plotters
                view = plotter_ui(pl)
                ctrl.view_update = view.update
      
server.start()

What is a LUT ?

[jourdain]

LUT is LookupTable...

[Oguitton]

ok, so colors and range would be base on it ? Sorry I am a novice in this domain...

[banesullivan]

Here is a simple example with PyVista:

from trame.app import get_server
from trame.ui.vuetify import SinglePageLayout
from trame.widgets import vuetify

import pyvista as pv
from pyvista import examples
from pyvista.trame.ui import plotter_ui

# -----------------------------------------------------------------------------
# Trame initialization
# -----------------------------------------------------------------------------

pv.OFF_SCREEN = True

server = get_server()
state, ctrl = server.state, server.controller

state.trame__title = "Modify Scalar Range"
ctrl.on_server_ready.add(ctrl.view_update)


# -----------------------------------------------------------------------------
# Plotting
# -----------------------------------------------------------------------------

mesh = pv.Wavelet()

pl = pv.Plotter()
actor = pl.add_mesh(mesh)


# -----------------------------------------------------------------------------
# Callbacks
# -----------------------------------------------------------------------------


@state.change("scalar_range")
def set_scalar_range(scalar_range=mesh.get_data_range(), **kwargs):
    actor.mapper.scalar_range = scalar_range
    ctrl.view_update()


# -----------------------------------------------------------------------------
# GUI
# -----------------------------------------------------------------------------


with SinglePageLayout(server) as layout:
    layout.title.set_text("Scalar Selection")
    layout.icon.click = ctrl.view_reset_camera

    with layout.toolbar:
        vuetify.VSpacer()
        vuetify.VRangeSlider(
            thumb_size=16,
            thumb_label=True,
            label="Range",
            v_model=("scalar_range", [0, 300]),
            min=('0',),
            max=('500',),
            dense=True,
            hide_details=True,
            style="max-width: 400px",
        )

    with layout.content:
        with vuetify.VContainer(
            fluid=True,
            classes="pa-0 fill-height",
        ):
            # Use PyVista UI template for Plotters
            view = plotter_ui(pl, default_server_rendering=True)
            ctrl.view_update = view.update

server.start()

Screen.Recording.2023-07-06.at.8.58.38.AM.mov

[jourdain]

If you could provide a tiny example reproducing the issue, that could help.
One possible reason could be that vtk.js is not properly invalidating some gpu data when transparency is involved.

[Oguitton]

Hi,
Yes I did two small examples, one without the transparency and the other one with it.
The only things that change is this line (number 156) :
mesh_add = pl.add_mesh(mesh[i],scalars='LogRes',cmap=my_colormap, opacity=C[i],use_transparency=True)
or :
mesh_add = pl.add_mesh(mesh[i],scalars='LogRes',cmap=my_colormap, lighting=False)
Everythings is in the zip, data and codes.
Thanks for your help

github.zip

[jourdain]

Just tried and that seems very strange indeed. Wondering if because of the piecewise function, the range get fixed within the code path of PyVista or something.

[banesullivan]

The issue is that this opacity is cell-wise (as opposed to being a transfer function). When you pass cell-wise opacity like these, we are no longer mapping the values but create the mapping upfront then change the values to RGBA to directly show these values.

The relevant code in PyVista is here:

https://github.com/pyvista/pyvista/blob/b20dc6942f9bd62ae4ebe0582f9cbc8a2f28f25a/pyvista/plotting/_plotting.py#L171-L177

Unfortunately updating the scalar range with this sort of opacity handling is not well supported at the moment.

[Oguitton]

Hi, Thanks for your explanation, we will do without this opacity filter for now.
Thanks both of you for your time and your help.