From 2f60ee5b2a32c2e672b9e81990d5776476115e44 Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Fri, 17 May 2024 22:03:33 -0500 Subject: [PATCH 01/13] created initial tutorial notebook file --- 3D_Visualization_Tools_Tutorial.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 3D_Visualization_Tools_Tutorial.ipynb diff --git a/3D_Visualization_Tools_Tutorial.ipynb b/3D_Visualization_Tools_Tutorial.ipynb new file mode 100644 index 0000000..e69de29 From 6db9f556dc3ddf6a76455b72e4d94a678b338d71 Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Fri, 17 May 2024 22:13:06 -0500 Subject: [PATCH 02/13] moving the 3D vis notebook to examples dir --- .../3D_Visualization_Tools_Tutorial.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 3D_Visualization_Tools_Tutorial.ipynb => examples/3D_Visualization_Tools_Tutorial.ipynb (100%) diff --git a/3D_Visualization_Tools_Tutorial.ipynb b/examples/3D_Visualization_Tools_Tutorial.ipynb similarity index 100% rename from 3D_Visualization_Tools_Tutorial.ipynb rename to examples/3D_Visualization_Tools_Tutorial.ipynb From 3bbce0c3ddc9306e955261d3125a5668530d0f40 Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Thu, 16 May 2024 16:10:34 -0500 Subject: [PATCH 03/13] testing a different server --- new.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 new.txt diff --git a/new.txt b/new.txt new file mode 100644 index 0000000..e69de29 From c97fac800384c82f4b4d8f168bbe0d2b78146812 Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Thu, 16 May 2024 16:16:56 -0500 Subject: [PATCH 04/13] deleted new.txt --- new.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 new.txt diff --git a/new.txt b/new.txt deleted file mode 100644 index e69de29..0000000 From 164341c956e2926c37fca5f026cdd1ac4a9dcebd Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Thu, 16 May 2024 17:18:08 -0500 Subject: [PATCH 05/13] changed bounding box, orthogonal slices, and isosurfaces plots for numpy array dtype --- dpm_tools/visualization/_plot_3d.py | 54 +++++++++++++++++++++++------ 1 file changed, 43 insertions(+), 11 deletions(-) diff --git a/dpm_tools/visualization/_plot_3d.py b/dpm_tools/visualization/_plot_3d.py index 7a87158..d23906d 100644 --- a/dpm_tools/visualization/_plot_3d.py +++ b/dpm_tools/visualization/_plot_3d.py @@ -11,7 +11,7 @@ def orthogonal_slices(data, fig: pv.DataSet = None, show_slices: list = None, pl Plots 3 orthogonal slices of a 3D image. Parameters: - data: A dataclass containing 3D image data + data: A np array containing 3D image data fig: Pyvista plotter object show_slices: List of slices in x, y, z to show. Default is middle slice in each direction. plotter_kwargs: Additional keyword arguments to pass to the plotter. @@ -22,7 +22,10 @@ def orthogonal_slices(data, fig: pv.DataSet = None, show_slices: list = None, pl """ if show_slices is None: + """ show_slices = [data.nx // 2, data.ny // 2, data.nz // 2] + """ + show_slices = [data.shape[1] // 2, data.shape[2] // 2, data.shape[0] // 2] # Overriding the above line because it prevents orthogonal slices from showing for some reason. if plotter_kwargs is None: @@ -35,16 +38,24 @@ def orthogonal_slices(data, fig: pv.DataSet = None, show_slices: list = None, pl x_slice, y_slice, z_slice = show_slices # Tests to make sure input slices are within image dimensions + """ assert 0 <= x_slice < data.nx, "X-slice value outside image dimensions" assert 0 <= y_slice < data.ny, "Y-slice value outside image dimensions" assert 0 <= z_slice < data.nz, "Z-slice value outside image dimensions" + """ + assert 0 <= x_slice < data.shape[1], "X-slice value outside image dimensions" + assert 0 <= y_slice < data.shape[2], "Y-slice value outside image dimensions" + assert 0 <= z_slice < data.shape[0], "Z-slice value outside image dimensions" # Initialize plotter object if fig is None: fig = _initialize_plotter(**plotter_kwargs) # Swapping axes for pyvista compatibility + ''' ax_swap_arr = np.swapaxes(data.scalar, 0, 2) + ''' + ax_swap_arr = np.swapaxes(data, 0, 2) # Wrap NumPy array to pyvista object pv_image_obj = _wrap_array(ax_swap_arr) @@ -78,7 +89,8 @@ def update(self): fig.add_mesh(starting_mesh,name='timestep_mesh', **mesh_kwargs, show_scalar_bar=False) _ = fig.add_scalar_bar(position_x=0.9, position_y= 0.2, height=0.5, vertical=True) fig.add_slider_widget(callback=lambda value: engine('z', int(value)), - rng = [1, data.nz-1], + # rng = [1, data.nz-1], + rng = [1, data.shape[0]-1], value=50, pointa=(0.025, 0.1), pointb=(0.31, 0.1), @@ -86,7 +98,8 @@ def update(self): fmt="%0.f", style='modern') fig.add_slider_widget(callback=lambda value: engine('x', int(value)), - rng = [1, data.nx-1], + # rng = [1, data.nx-1], + rng = [1, data.shape[1]-1], value=50, pointa=(0.35, 0.1), pointb=(0.64, 0.1), @@ -94,7 +107,8 @@ def update(self): fmt="%0.f", style='modern') fig.add_slider_widget(callback=lambda value: engine('y', int(value)), - rng = [1, data.ny-1], + # rng = [1, data.ny-1], + rng = [1, data.shape[2]-1], value=50, pointa=(0.67, 0.1), pointb=(0.98, 0.1), @@ -161,14 +175,22 @@ def plot_isosurface(data, fig: pv.Plotter = None, show_isosurface: list = None, if fig is None: fig = _initialize_plotter(**plotter_kwargs) - + ''' pv_image_obj = _wrap_array(data.scalar) + ''' + pv_image_obj = _wrap_array(data) if show_isosurface is None: + ''' show_isosurface = [(np.amax(data.scalar)+np.amin(data.scalar))/2] warnings.warn('\n\nNo value provided for \'show_isosurfaces\' keyword.'+ f'Using the midpoint of the isosurface array instead ({np.amin(data.scalar)},{np.amax(data.scalar)}).\n', stacklevel=2) + ''' + show_isosurface = [(np.amax(data)+np.amin(data))/2] + warnings.warn('\n\nNo value provided for \'show_isosurfaces\' keyword.'+ + f'Using the midpoint of the isosurface array instead ({np.amin(data)},{np.amax(data)}).\n', + stacklevel=2) contours = pv_image_obj.contour(isosurfaces=show_isosurface) @@ -200,8 +222,11 @@ def bounding_box(data, fig: pv.Plotter = None, mesh_kwargs: dict = None, plotter mesh_kwargs = {'opacity': 0.2, 'color': (1, 1, 1)} - - wall_bin = data.scalar.copy() + ''' + wall_bin = data.scalar.copy() + + ''' + wall_bin = data.copy() wall_bin[1:-1, 1:-1, 1:-1] = 255 vtk_wall = _wrap_array(wall_bin) wall_contours = vtk_wall.contour([255]) @@ -242,10 +267,10 @@ def plot_glyph(vector_data, fig: pv.Plotter = None, glyph: pv.PolyData = None, g glyph_kwargs['orient'] = [vector_data.vector[i][::glyph_space, ::glyph_space, ::glyph_space]/np.max(vector_data.magnitude) for i in range(3)] # plotter_kwargs, mesh_kwargs = _initialize_kwargs(plotter_kwargs, mesh_kwargs) - x, y, z = np.mgrid[:vector_data.nx:glyph_space, :vector_data.ny:glyph_space, :vector_data.nz:glyph_space] + # Pseudo mesh for scale bar of the figure ##################################### glyph_kwargs2 = {'scale': array*np.max(vector_data.magnitude), @@ -388,10 +413,15 @@ def plot_scalar_volume(data, fig: pv.Plotter = None, mesh_kwargs: dict = None, # wall_bin[1:-1, 1:-1, 1:-1] = data.scalar.copy() # pv_image_obj = _wrap_array(data.scalar) - + ''' mesh = pv.ImageData(dimensions=(data.nz, data.ny, data.nx), spacing=(1.0, 1.0, 1.0), origin=(0.0, 0.0, 0.0)) + ''' + + mesh = pv.ImageData(dimensions=(data.shape[0], data.shape[2], data.shape[1]), + spacing=(1.0, 1.0, 1.0), + origin=(0.0, 0.0, 0.0)) mesh['scalars'] = data.scalar.flatten(order="F") @@ -438,8 +468,10 @@ def plot_medial_axis(data, fig: pv.Plotter = None, show_isosurface: list = None, if fig is None: fig = _initialize_plotter(**plotter_kwargs) - - medial_axis = skimage.morphology.skeletonize(data.scalar) + ''' + medial_axis = skimage.morphology.skeletonize(data.scalar) + ''' + medial_axis = skimage.morphology.skeletonize(data) pv_image_obj = _wrap_array(medial_axis) contours_ma = pv_image_obj.contour(isosurfaces=[0.5]) From fcf7e7d5c62fbefd15785b6272ccf2eaaf63f251 Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Sat, 18 May 2024 23:07:19 -0500 Subject: [PATCH 06/13] modified example visualization notebook. --- .../3D_Visualization_Tools_Tutorial.ipynb | 242 ++++++++++++++++++ 1 file changed, 242 insertions(+) diff --git a/examples/3D_Visualization_Tools_Tutorial.ipynb b/examples/3D_Visualization_Tools_Tutorial.ipynb index e69de29..6d96f3a 100644 --- a/examples/3D_Visualization_Tools_Tutorial.ipynb +++ b/examples/3D_Visualization_Tools_Tutorial.ipynb @@ -0,0 +1,242 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8c81d0ea", + "metadata": {}, + "source": [ + "## This notebook contains examples for 3D visualization tools/functions of DPM Tools." + ] + }, + { + "cell_type": "markdown", + "id": "ec484a0f", + "metadata": {}, + "source": [ + "Installing dpm_tools." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4c2c002f", + "metadata": {}, + "outputs": [], + "source": [ + "# import os\n", + "# os.chdir('/home1/09429/cinarturhan/GitHub/')\n", + "# !pip install -e dpm_tools\n", + "# os.chdir('/home1/09429/cinarturhan/GitHub/dpm_tools/examples')" + ] + }, + { + "cell_type": "markdown", + "id": "c9a6b693", + "metadata": {}, + "source": [ + "Importing the required packages." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9673eef2", + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import numpy as np\n", + "import glob" + ] + }, + { + "cell_type": "markdown", + "id": "cb3b8aad", + "metadata": {}, + "source": [ + "Importing visualization moduel of the dpm_tools package." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6766be6c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from dpm_tools import visualization as dpm_vis" + ] + }, + { + "cell_type": "markdown", + "id": "c1c8bf85", + "metadata": {}, + "source": [ + "Defining a function to download data from Digital Rocks Portal. The data is x-ray microtomography data from the Network Generation Comparison Forum and is available on the Digital Rocks Portal (https://www.digitalrocksportal.org/projects/16)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "508d0b75", + "metadata": {}, + "outputs": [], + "source": [ + "# Function to download files\n", + "def download_file_url(file_url,filename):\n", + " # download file\n", + " r = requests.get(file_url, stream = True) \n", + "\n", + " with open(filename,\"wb\") as f: \n", + " for chunk in r.iter_content(chunk_size=1024): \n", + "\n", + " # writing one chunk at a time to pdf file \n", + " if chunk: \n", + " f.write(chunk)\n", + " return()\n", + "\n", + "# Downloading the data\n", + "parent_dir = '../data/'\n", + "file_names = ['gambier.ubc', 'beadpack.ubc', 'sandpack.ubc', 'castlegate.ubc']\n", + "file_dirs = [parent_dir+file for file in file_names]\n", + "file_links = ['https://www.digitalrocksportal.org/projects/16/images/65565/download/',\n", + " 'https://www.digitalrocksportal.org/projects/16/images/65563/download/',\n", + " 'https://www.digitalrocksportal.org/projects/16/images/65566/download/',\n", + " 'https://www.digitalrocksportal.org/projects/16/images/65564/download/']\n", + "\n", + "for i in range(0,len(file_dirs)):\n", + " download_file_url(file_links[i],file_dirs[i])" + ] + }, + { + "cell_type": "markdown", + "id": "97cbbf24", + "metadata": {}, + "source": [ + "Checking the image list and importing the data to the notebook. We have preprocessed the data to have solid and pore labeled as 0 and 1, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b4453309", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['../data/beadpack.ubc', '../data/castlegate.ubc', '../data/gambier.ubc', '../data/sandpack.ubc']\n" + ] + } + ], + "source": [ + "# Checking image list\n", + "img_list = sorted(glob.glob('../data/*.ubc'))\n", + "print(img_list)\n", + "\n", + "# Reading Images\n", + "beadpack, castlegate, gambier, sandpack = [np.fromfile(img,dtype='uint8') for img in img_list]\n", + "\n", + "# Reshaping Images\n", + "gambier = gambier.reshape((512,512,512))\n", + "castlegate = castlegate.reshape((512,512,512))\n", + "beadpack = beadpack.reshape((512,512,512))\n", + "sandpack = sandpack.reshape((512,512,512))\n", + "\n", + "# Inverting the binary arrays (switching void and solid phases)\n", + "gambier = np.invert(gambier==True).astype('uint8')\n", + "castlegate = np.invert(castlegate==True).astype('uint8')\n", + "beadpack = np.invert(beadpack==True).astype('uint8')\n", + "sandpack = np.invert(sandpack==True).astype('uint8')" + ] + }, + { + "cell_type": "markdown", + "id": "0ec1f5e7", + "metadata": {}, + "source": [ + "Getting a subset from the data for faster visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "4f7fae92", + "metadata": {}, + "outputs": [], + "source": [ + "sandpack = sandpack[0:100, 0:100, 0:100]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ac2db7d4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home1/09429/cinarturhan/.local/lib/python3.9/site-packages/pyvista/plotting/plotter.py:151: UserWarning: \n", + "This system does not appear to be running an xserver.\n", + "PyVista will likely segfault when rendering.\n", + "\n", + "Try starting a virtual frame buffer with xvfb, or using\n", + " ``pyvista.start_xvfb()``\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'numpy.ndarray' object has no attribute 'scalar'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_2723662/1440302689.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdpm_vis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_isosurface\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msandpack\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/GitHub/dpm_tools/dpm_tools/visualization/_plot_3d.py\u001b[0m in \u001b[0;36mplot_isosurface\u001b[0;34m(data, fig, show_isosurface, mesh_kwargs, plotter_kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_initialize_plotter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mplotter_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 165\u001b[0;31m \u001b[0mpv_image_obj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_wrap_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscalar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mshow_isosurface\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'scalar'" + ] + } + ], + "source": [ + "\n", + "dpm_vis.plot_isosurface(sandpack)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ca3307f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 96508de0a56d06f79b68c55af753f2d19931632f Mon Sep 17 00:00:00 2001 From: cinarturhan <105860395+cinarturhan@users.noreply.github.com> Date: Sun, 19 May 2024 00:27:59 -0500 Subject: [PATCH 07/13] completed 3d vis static tutorial commands and kept the image class --- dpm_tools/visualization/_plot_3d.py | 52 ++--- .../3D_Visualization_Tools_Tutorial.ipynb | 180 ++++++++++++++---- 2 files changed, 152 insertions(+), 80 deletions(-) diff --git a/dpm_tools/visualization/_plot_3d.py b/dpm_tools/visualization/_plot_3d.py index d23906d..8b3f22f 100644 --- a/dpm_tools/visualization/_plot_3d.py +++ b/dpm_tools/visualization/_plot_3d.py @@ -22,10 +22,7 @@ def orthogonal_slices(data, fig: pv.DataSet = None, show_slices: list = None, pl """ if show_slices is None: - """ show_slices = [data.nx // 2, data.ny // 2, data.nz // 2] - """ - show_slices = [data.shape[1] // 2, data.shape[2] // 2, data.shape[0] // 2] # Overriding the above line because it prevents orthogonal slices from showing for some reason. if plotter_kwargs is None: @@ -38,24 +35,17 @@ def orthogonal_slices(data, fig: pv.DataSet = None, show_slices: list = None, pl x_slice, y_slice, z_slice = show_slices # Tests to make sure input slices are within image dimensions - """ assert 0 <= x_slice < data.nx, "X-slice value outside image dimensions" assert 0 <= y_slice < data.ny, "Y-slice value outside image dimensions" assert 0 <= z_slice < data.nz, "Z-slice value outside image dimensions" - """ - assert 0 <= x_slice < data.shape[1], "X-slice value outside image dimensions" - assert 0 <= y_slice < data.shape[2], "Y-slice value outside image dimensions" - assert 0 <= z_slice < data.shape[0], "Z-slice value outside image dimensions" + # Initialize plotter object if fig is None: fig = _initialize_plotter(**plotter_kwargs) # Swapping axes for pyvista compatibility - ''' ax_swap_arr = np.swapaxes(data.scalar, 0, 2) - ''' - ax_swap_arr = np.swapaxes(data, 0, 2) # Wrap NumPy array to pyvista object pv_image_obj = _wrap_array(ax_swap_arr) @@ -89,8 +79,7 @@ def update(self): fig.add_mesh(starting_mesh,name='timestep_mesh', **mesh_kwargs, show_scalar_bar=False) _ = fig.add_scalar_bar(position_x=0.9, position_y= 0.2, height=0.5, vertical=True) fig.add_slider_widget(callback=lambda value: engine('z', int(value)), - # rng = [1, data.nz-1], - rng = [1, data.shape[0]-1], + rng = [1, data.nz-1], value=50, pointa=(0.025, 0.1), pointb=(0.31, 0.1), @@ -98,8 +87,7 @@ def update(self): fmt="%0.f", style='modern') fig.add_slider_widget(callback=lambda value: engine('x', int(value)), - # rng = [1, data.nx-1], - rng = [1, data.shape[1]-1], + rng = [1, data.nx-1], value=50, pointa=(0.35, 0.1), pointb=(0.64, 0.1), @@ -107,8 +95,7 @@ def update(self): fmt="%0.f", style='modern') fig.add_slider_widget(callback=lambda value: engine('y', int(value)), - # rng = [1, data.ny-1], - rng = [1, data.shape[2]-1], + rng = [1, data.ny-1], value=50, pointa=(0.67, 0.1), pointb=(0.98, 0.1), @@ -175,22 +162,15 @@ def plot_isosurface(data, fig: pv.Plotter = None, show_isosurface: list = None, if fig is None: fig = _initialize_plotter(**plotter_kwargs) - ''' + pv_image_obj = _wrap_array(data.scalar) - ''' - pv_image_obj = _wrap_array(data) + if show_isosurface is None: - ''' show_isosurface = [(np.amax(data.scalar)+np.amin(data.scalar))/2] warnings.warn('\n\nNo value provided for \'show_isosurfaces\' keyword.'+ f'Using the midpoint of the isosurface array instead ({np.amin(data.scalar)},{np.amax(data.scalar)}).\n', stacklevel=2) - ''' - show_isosurface = [(np.amax(data)+np.amin(data))/2] - warnings.warn('\n\nNo value provided for \'show_isosurfaces\' keyword.'+ - f'Using the midpoint of the isosurface array instead ({np.amin(data)},{np.amax(data)}).\n', - stacklevel=2) contours = pv_image_obj.contour(isosurfaces=show_isosurface) @@ -221,12 +201,8 @@ def bounding_box(data, fig: pv.Plotter = None, mesh_kwargs: dict = None, plotter if mesh_kwargs is None: mesh_kwargs = {'opacity': 0.2, 'color': (1, 1, 1)} - - ''' - wall_bin = data.scalar.copy() - ''' - wall_bin = data.copy() + wall_bin = data.scalar.copy() wall_bin[1:-1, 1:-1, 1:-1] = 255 vtk_wall = _wrap_array(wall_bin) wall_contours = vtk_wall.contour([255]) @@ -413,15 +389,10 @@ def plot_scalar_volume(data, fig: pv.Plotter = None, mesh_kwargs: dict = None, # wall_bin[1:-1, 1:-1, 1:-1] = data.scalar.copy() # pv_image_obj = _wrap_array(data.scalar) - ''' + mesh = pv.ImageData(dimensions=(data.nz, data.ny, data.nx), spacing=(1.0, 1.0, 1.0), origin=(0.0, 0.0, 0.0)) - ''' - - mesh = pv.ImageData(dimensions=(data.shape[0], data.shape[2], data.shape[1]), - spacing=(1.0, 1.0, 1.0), - origin=(0.0, 0.0, 0.0)) mesh['scalars'] = data.scalar.flatten(order="F") @@ -468,10 +439,9 @@ def plot_medial_axis(data, fig: pv.Plotter = None, show_isosurface: list = None, if fig is None: fig = _initialize_plotter(**plotter_kwargs) - ''' - medial_axis = skimage.morphology.skeletonize(data.scalar) - ''' - medial_axis = skimage.morphology.skeletonize(data) + + medial_axis = skimage.morphology.skeletonize(data.scalar) + pv_image_obj = _wrap_array(medial_axis) contours_ma = pv_image_obj.contour(isosurfaces=[0.5]) diff --git a/examples/3D_Visualization_Tools_Tutorial.ipynb b/examples/3D_Visualization_Tools_Tutorial.ipynb index 6d96f3a..92fa609 100644 --- a/examples/3D_Visualization_Tools_Tutorial.ipynb +++ b/examples/3D_Visualization_Tools_Tutorial.ipynb @@ -39,14 +39,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "id": "9673eef2", "metadata": {}, "outputs": [], "source": [ "import requests\n", "import numpy as np\n", - "import glob" + "import glob\n", + "import pyvista as pv\n", + "pv.set_jupyter_backend('server')" ] }, { @@ -59,14 +61,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "6766be6c", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "from dpm_tools import visualization as dpm_vis" + "from dpm_tools import visualization as dpm_vis\n", + "from dpm_tools import io" ] }, { @@ -79,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "508d0b75", "metadata": {}, "outputs": [], @@ -120,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "id": "b4453309", "metadata": {}, "outputs": [ @@ -146,11 +149,11 @@ "beadpack = beadpack.reshape((512,512,512))\n", "sandpack = sandpack.reshape((512,512,512))\n", "\n", - "# Inverting the binary arrays (switching void and solid phases)\n", - "gambier = np.invert(gambier==True).astype('uint8')\n", - "castlegate = np.invert(castlegate==True).astype('uint8')\n", - "beadpack = np.invert(beadpack==True).astype('uint8')\n", - "sandpack = np.invert(sandpack==True).astype('uint8')" + "# # Inverting the binary arrays (switching void and solid phases)\n", + "# gambier = np.invert(gambier==True).astype('uint8')\n", + "# castlegate = np.invert(castlegate==True).astype('uint8')\n", + "# beadpack = np.invert(beadpack==True).astype('uint8')\n", + "# sandpack = np.invert(sandpack==True).astype('uint8')" ] }, { @@ -163,59 +166,158 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "id": "4f7fae92", "metadata": {}, "outputs": [], "source": [ - "sandpack = sandpack[0:100, 0:100, 0:100]" + "sandpack = sandpack[0:100, 0:100, 0:100]\n", + "image = io.Image(scalar=sandpack)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "808c241c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = dpm_vis.plot_slice(image, slice_num=50)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 25, "id": "ac2db7d4", "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "080af37e48c84e89a6f7eea22bd9df6c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Widget(value='