| 1 |
"""PyVista Trame Viewer class for a Vue 2 client. |
| 2 |
|
| 3 |
This class, derived from `pyvista.trame.ui.base_viewer`, |
| 4 |
is intended for use with a trame application where the client type is "vue2". |
| 5 |
Therefore, the `ui` method implemented by this class utilizes the API of Vuetify 2. |
| 6 |
""" |
| 7 |
|
| 8 |
from __future__ import annotations |
| 9 |
|
| 10 |
from typing import TYPE_CHECKING |
| 11 |
|
| 12 |
from trame.ui.vuetify2 import VAppLayout |
| 13 |
from trame.widgets import html |
| 14 |
from trame.widgets import vuetify |
| 15 |
|
| 16 |
from pyvista.trame.views import PyVistaLocalView |
| 17 |
from pyvista.trame.views import PyVistaRemoteLocalView |
| 18 |
from pyvista.trame.views import PyVistaRemoteView |
| 19 |
|
| 20 |
from .base_viewer import BaseViewer |
| 21 |
|
| 22 |
if TYPE_CHECKING: |
| 23 |
from trame_client.ui.core import AbstractLayout |
| 24 |
|
| 25 |
|
| 26 |
def button(click, icon, tooltip): # numpydoc ignore=PR01 |
| 27 |
"""Create a vuetify button.""" |
| 28 |
with vuetify.VTooltip(bottom=True): |
| 29 |
with vuetify.Template(v_slot_activator='{ on, attrs }'): |
| 30 |
with vuetify.VBtn(icon=True, v_bind='attrs', v_on='on', click=click): |
| 31 |
vuetify.VIcon(icon) |
| 32 |
html.Span(tooltip) |
| 33 |
|
| 34 |
|
| 35 |
def checkbox(model, icons, tooltip): # numpydoc ignore=PR01 |
| 36 |
"""Create a vuetify checkbox.""" |
| 37 |
with vuetify.VTooltip(bottom=True): |
| 38 |
with vuetify.Template(v_slot_activator='{ on, attrs }'): |
| 39 |
with html.Div(v_on='on', v_bind='attrs'): |
| 40 |
vuetify.VCheckbox( |
| 41 |
v_model=model, |
| 42 |
on_icon=icons[0], |
| 43 |
off_icon=icons[1], |
| 44 |
dense=True, |
| 45 |
hide_details=True, |
| 46 |
classes='my-0 py-0 ml-1', |
| 47 |
) |
| 48 |
html.Span(tooltip) |
| 49 |
|
| 50 |
|
| 51 |
def slider(model, tooltip, **kwargs): # numpydoc ignore=PR01 |
| 52 |
"""Create a vuetify slider.""" |
| 53 |
with vuetify.VTooltip(bottom=True): |
| 54 |
with vuetify.Template(v_slot_activator='{ on, attrs }'): |
| 55 |
with html.Div(v_on='on', v_bind='attrs'): |
| 56 |
vuetify.VSlider(v_model=model, **kwargs) |
| 57 |
html.Span(tooltip) |
| 58 |
|
| 59 |
|
| 60 |
def text_field(model, tooltip, **kwargs): # numpydoc ignore=PR01 |
| 61 |
"""Create a vuetify text field.""" |
| 62 |
with vuetify.VTooltip(bottom=True): |
| 63 |
with vuetify.Template(v_slot_activator='{ on, attrs }'): |
| 64 |
with html.Div(v_on='on', v_bind='attrs'): |
| 65 |
vuetify.VTextField(v_model=model, **kwargs) |
| 66 |
html.Span(tooltip) |
| 67 |
|
| 68 |
|
| 69 |
def select(model, tooltip, **kwargs): # numpydoc ignore=PR01 |
| 70 |
"""Create a vuetify select menu.""" |
| 71 |
with vuetify.VTooltip(bottom=True): |
| 72 |
with vuetify.Template(v_slot_activator='{ on, attrs }'): |
| 73 |
with html.Div(v_on='on', v_bind='attrs'): |
| 74 |
vuetify.VSelect(v_model=model, **kwargs) |
| 75 |
html.Span(tooltip) |
| 76 |
|
| 77 |
|
| 78 |
def divider(**kwargs): # numpydoc ignore=PR01 |
| 79 |
"""Create a vuetify divider.""" |
| 80 |
vuetify.VDivider(**kwargs) |
| 81 |
|
| 82 |
|
| 83 |
class Viewer(BaseViewer): |
| 84 |
"""Viewer implementation compatible with Vue 2 Trame Applications.""" |
| 85 |
|
| 86 |
def __init__(self, *args, **kwargs): |
| 87 |
super().__init__(*args, **kwargs) |
| 88 |
|
| 89 |
def make_layout(self, *args, **kwargs) -> AbstractLayout: |
| 90 |
"""Create instance of an AbstractLayout which is appropriate for this viewer. |
| 91 |
|
| 92 |
Parameters |
| 93 |
---------- |
| 94 |
*args : tuple |
| 95 |
Positional arguments. |
| 96 |
|
| 97 |
**kwargs : dict, optional |
| 98 |
Keyword arguments. |
| 99 |
|
| 100 |
Returns |
| 101 |
------- |
| 102 |
VAppLayout (vue2) |
| 103 |
A layout this viewer can be embedded in. |
| 104 |
|
| 105 |
""" |
| 106 |
return VAppLayout(*args, **kwargs) |
| 107 |
|
| 108 |
def ui_controls(self, mode=None, default_server_rendering=True, v_show=None): |
| 109 |
"""Create a VRow for the UI controls. |
| 110 |
|
| 111 |
Parameters |
| 112 |
---------- |
| 113 |
mode : str, default: 'trame' |
| 114 |
The UI view mode. Options are: |
| 115 |
|
| 116 |
* ``'trame'``: Uses a view that can switch between client and server |
| 117 |
rendering modes. |
| 118 |
* ``'server'``: Uses a view that is purely server rendering. |
| 119 |
* ``'client'``: Uses a view that is purely client rendering (generally |
| 120 |
safe without a virtual frame buffer) |
| 121 |
|
| 122 |
default_server_rendering : bool, default: True |
| 123 |
Whether to use server-side or client-side rendering on-start when |
| 124 |
using the ``'trame'`` mode. |
| 125 |
|
| 126 |
v_show : bool, optional |
| 127 |
Conditionally show the viewer controls. |
| 128 |
|
| 129 |
""" |
| 130 |
with vuetify.VRow( |
| 131 |
v_show=v_show, |
| 132 |
classes='pa-0 ma-0 align-center', |
| 133 |
) as row: |
| 134 |
server = row.server |
| 135 |
# Listen to state changes |
| 136 |
server.state.change(self.EDGES)(self.on_edge_visibility_change) |
| 137 |
server.state.change(self.GRID)(self.on_grid_visibility_change) |
| 138 |
server.state.change(self.OUTLINE)(self.on_outline_visibility_change) |
| 139 |
server.state.change(self.AXIS)(self.on_axis_visibility_change) |
| 140 |
server.state.change(self.PARALLEL)(self.on_parallel_projection_change) |
| 141 |
server.state.change(self.SERVER_RENDERING)(self.on_rendering_mode_change) |
| 142 |
vuetify.VDivider(vertical=True, classes='mr-1') |
| 143 |
button( |
| 144 |
click=self.reset_camera, |
| 145 |
icon='mdi-arrow-expand-all', |
| 146 |
tooltip='Reset Camera', |
| 147 |
) |
| 148 |
vuetify.VDivider(vertical=True, classes='mx-1') |
| 149 |
button( |
| 150 |
click=self.view_isometric, |
| 151 |
icon='mdi-axis-arrow', |
| 152 |
tooltip='Perspective view', |
| 153 |
) |
| 154 |
button( |
| 155 |
click=self.view_yz, |
| 156 |
icon='mdi-axis-x-arrow', |
| 157 |
tooltip='Reset Camera X', |
| 158 |
) |
| 159 |
button( |
| 160 |
click=self.view_xz, |
| 161 |
icon='mdi-axis-y-arrow', |
| 162 |
tooltip='Reset Camera Y', |
| 163 |
) |
| 164 |
button( |
| 165 |
click=self.view_xy, |
| 166 |
icon='mdi-axis-z-arrow', |
| 167 |
tooltip='Reset Camera Z', |
| 168 |
) |
| 169 |
vuetify.VDivider(vertical=True, classes='mx-1') |
| 170 |
checkbox( |
| 171 |
model=(self.EDGES, False), |
| 172 |
icons=('mdi-grid', 'mdi-grid-off'), |
| 173 |
tooltip=f"Toggle edge visibility ({{{{ {self.EDGES} ? 'on' : 'off' }}}})", |
| 174 |
) |
| 175 |
checkbox( |
| 176 |
model=(self.OUTLINE, False), |
| 177 |
icons=('mdi-cube', 'mdi-cube-off'), |
| 178 |
tooltip=f"Toggle bounding box ({{{{ {self.OUTLINE} ? 'on' : 'off' }}}})", |
| 179 |
) |
| 180 |
checkbox( |
| 181 |
model=(self.GRID, False), |
| 182 |
icons=('mdi-ruler-square', 'mdi-ruler-square'), |
| 183 |
tooltip=f"Toggle ruler ({{{{ {self.GRID} ? 'on' : 'off' }}}})", |
| 184 |
) |
| 185 |
checkbox( |
| 186 |
model=(self.AXIS, False), |
| 187 |
icons=('mdi-axis-arrow-info', 'mdi-axis-arrow-info'), |
| 188 |
tooltip=f"Toggle axis ({{{{ {self.AXIS} ? 'on' : 'off' }}}})", |
| 189 |
) |
| 190 |
# Server rendering options |
| 191 |
if mode == 'trame': |
| 192 |
vuetify.VDivider(vertical=True, classes='mx-1') |
| 193 |
checkbox( |
| 194 |
model=(self.SERVER_RENDERING, default_server_rendering), |
| 195 |
icons=('mdi-dns', 'mdi-open-in-app'), |
| 196 |
tooltip=f'Toggle rendering mode ' |
| 197 |
f"({{{{ {self.SERVER_RENDERING} ? 'remote' : 'local' }}}})", |
| 198 |
) |
| 199 |
with vuetify.VRow( |
| 200 |
v_show=(self.SERVER_RENDERING, default_server_rendering), |
| 201 |
classes='pa-0 ma-0 align-center', |
| 202 |
): |
| 203 |
checkbox( |
| 204 |
model=(self.PARALLEL, False), |
| 205 |
icons=('mdi-camera-off', 'mdi-camera-switch'), |
| 206 |
tooltip=f'Toggle parallel projection ' |
| 207 |
f"({{{{ {self.PARALLEL} ? 'on' : 'off' }}}})", |
| 208 |
) |
| 209 |
|
| 210 |
def attach_screenshot(): |
| 211 |
return server.protocol.addAttachment(self.screenshot()) |
| 212 |
|
| 213 |
button( |
| 214 |
# Must use single-quote string for JS here |
| 215 |
click=f"utils.download('screenshot.png', " |
| 216 |
f"trigger('{server.trigger_name(attach_screenshot)}'), " |
| 217 |
f"'image/png')", |
| 218 |
icon='mdi-file-png-box', |
| 219 |
tooltip='Save screenshot', |
| 220 |
) |
| 221 |
|
| 222 |
def attach_export(): |
| 223 |
return server.protocol.addAttachment(self.export()) |
| 224 |
|
| 225 |
button( |
| 226 |
# Must use single-quote string for JS here |
| 227 |
click="utils.download('scene-export.html', " |
| 228 |
f"trigger('{server.trigger_name(attach_export)}'), " |
| 229 |
"'application/octet-stream')", |
| 230 |
icon='mdi-download', |
| 231 |
tooltip='Export scene as HTML', |
| 232 |
) |
| 233 |
|
| 234 |
def ui( |
| 235 |
self, |
| 236 |
mode=None, |
| 237 |
default_server_rendering=True, |
| 238 |
collapse_menu=False, |
| 239 |
add_menu=True, |
| 240 |
add_menu_items=None, |
| 241 |
**kwargs, |
| 242 |
): |
| 243 |
"""Generate VContainer for PyVista Plotter. |
| 244 |
|
| 245 |
Parameters |
| 246 |
---------- |
| 247 |
mode : str, default: 'trame' |
| 248 |
The UI view mode. Options are: |
| 249 |
|
| 250 |
* ``'trame'``: Uses a view that can switch between client and server |
| 251 |
rendering modes. |
| 252 |
* ``'server'``: Uses a view that is purely server rendering. |
| 253 |
* ``'client'``: Uses a view that is purely client rendering (generally |
| 254 |
safe without a virtual frame buffer) |
| 255 |
|
| 256 |
default_server_rendering : bool, default: True |
| 257 |
Whether to use server-side or client-side rendering on-start when |
| 258 |
using the ``'trame'`` mode. |
| 259 |
|
| 260 |
collapse_menu : bool, default: False |
| 261 |
Collapse the UI menu (camera controls, etc.) on start. |
| 262 |
|
| 263 |
add_menu : bool, default: True |
| 264 |
Add a UI controls VCard to the VContainer. |
| 265 |
|
| 266 |
add_menu_items : callable, default: None |
| 267 |
Append more UI controls to the VCard menu. Should be a function similar to |
| 268 |
`Viewer.ui_controls()`. |
| 269 |
|
| 270 |
**kwargs : dict, optional |
| 271 |
Additional keyword arguments are passed to the view being created. |
| 272 |
|
| 273 |
Returns |
| 274 |
------- |
| 275 |
output : PyVistaRemoteLocalView | PyVistaRemoteView | PyVistaLocalView |
| 276 |
Trame view interface for pyvista. |
| 277 |
|
| 278 |
""" |
| 279 |
if mode is None: |
| 280 |
mode = self.plotter._theme.trame.default_mode |
| 281 |
if mode not in self.VALID_UI_MODES: |
| 282 |
msg = f'`{mode}` is not a valid mode choice. Use one of: {self.VALID_UI_MODES}' |
| 283 |
raise ValueError(msg) |
| 284 |
if mode != 'trame': |
| 285 |
default_server_rendering = mode == 'server' |
| 286 |
|
| 287 |
with vuetify.VContainer( |
| 288 |
fluid=True, |
| 289 |
classes='pa-0 fill-height', |
| 290 |
style='position: relative', |
| 291 |
trame_server=self.server, |
| 292 |
) as container: |
| 293 |
server = container.server |
| 294 |
# Initialize state variables |
| 295 |
server.state[self.EDGES] = False |
| 296 |
server.state[self.GRID] = self.plotter.renderer.cube_axes_actor is not None |
| 297 |
server.state[self.OUTLINE] = self.plotter.renderer._box_object is not None |
| 298 |
server.state[self.AXIS] = ( |
| 299 |
self.plotter.renderer.axes_widget is not None |
| 300 |
and self.plotter.renderer.axes_widget.GetEnabled() |
| 301 |
) |
| 302 |
server.state[self.SERVER_RENDERING] = default_server_rendering |
| 303 |
if add_menu: |
| 304 |
server.state[self.SHOW_UI] = not collapse_menu |
| 305 |
with vuetify.VCard( |
| 306 |
style='position: absolute; top: 20px; left: 20px; z-index: 1; height: 36px;', |
| 307 |
classes=(f"{{ 'rounded-circle': !{self.SHOW_UI} }}",), |
| 308 |
) as self.menu: |
| 309 |
with vuetify.VRow(classes='pa-0 ma-0'): |
| 310 |
button( |
| 311 |
click=f'{self.SHOW_UI}=!{self.SHOW_UI}', |
| 312 |
icon='mdi-dots-vertical', |
| 313 |
tooltip=f"{{{{ {self.SHOW_UI} ? 'Hide' : 'Show' }}}} menu", |
| 314 |
) |
| 315 |
self.ui_controls( |
| 316 |
mode=mode, |
| 317 |
default_server_rendering=default_server_rendering, |
| 318 |
v_show=(f'{self.SHOW_UI}',), |
| 319 |
) |
| 320 |
if callable(add_menu_items): |
| 321 |
with vuetify.VRow( |
| 322 |
v_show=(f'{self.SHOW_UI}',), |
| 323 |
classes='pa-0 ma-0 align-center', |
| 324 |
): |
| 325 |
add_menu_items() |
| 326 |
if mode == 'trame': |
| 327 |
view = PyVistaRemoteLocalView( |
| 328 |
self.plotter, |
| 329 |
mode=( |
| 330 |
# Must use single-quote string for JS here |
| 331 |
f"{self.SERVER_RENDERING} ? 'remote' : 'local'", |
| 332 |
'remote' if default_server_rendering else 'local', |
| 333 |
), |
| 334 |
**kwargs, |
| 335 |
) |
| 336 |
elif mode == 'server': |
| 337 |
view = PyVistaRemoteView(self.plotter, **kwargs) |
| 338 |
elif mode == 'client': |
| 339 |
view = PyVistaLocalView(self.plotter, **kwargs) |
| 340 |
|
| 341 |
self._html_views.add(view) |
| 342 |
if add_menu: |
| 343 |
view.menu = self.menu |
| 344 |
|
| 345 |
return view |