Create 3D Streamtube plot in Plotly

Question

Aim

I would like to create a 3D Streamtube Plot with Plotly.

Here is a cross-section of the vector field in the middle of the plot to give you an idea of how it looks like:

The final vector field should have rotational symmetry.

My Attempt

Download the data here: https://filebin.net/x6ywfuo6v4851v74
Run the code bellow:

Code:

import plotly.graph_objs as go
import plotly.express as px
import pandas as pd
import numpy as np

import plotly.io as pio
pio.renderers.default='browser'

# Import data to pandas
df = pd.read_csv("data.csv")
# Plot

X = np.linspace(0,1,101)
Y = np.linspace(0,1,10)
Z = np.linspace(0,1,101)

# Points from which the streamtubes should originate
xpos,ypos = np.meshgrid(X[::5],Y, indexing="xy")
xpos = xpos.reshape(1,-1)[0]
ypos = ypos.reshape(1,-1)[0]


starting_points = px.scatter_3d(
    x=xpos,
    y=ypos,
    z=[-500]*len(xpos)
    )
starting_points.show()

# Streamtube Plot

data_plot = [go.Streamtube(
    x = df['x'],
    y = df['y'],
    z = df['z'],
    u = df['u'],
    v = df['v'],
    w = df['w'],
    starts = dict(                           #Determines the streamtubes starting position.
          x=xpos,
          y=ypos,
          z=[-500]*len(xpos)
    ),
    #sizeref = 0.3,
    colorscale = 'jet',
    showscale = True,
    maxdisplayed = 300                      #Determines the maximum segments displayed in a streamtube.
)]

fig = go.Figure(data=data_plot)
fig.show()

The initial points (starting points) of the streamtubes seem to be nicely defined:

...but the resulting 3D streamtube plot is very weird:

Edit

I tried normalizing the field plot, but the result is still not satisfactory:

import plotly.graph_objs as go
import pandas as pd
import numpy as np

import plotly.io as pio
pio.renderers.default='browser'

# Import data to pandas
df = pd.read_csv("data.csv")

# NORMALIZE VECTOR FIELD -> between [0,1]
df["u"] = (df["u"]-df["u"].min()) / (df["u"].max()-df["u"].min())
df["v"] = (df["v"]-df["v"].min()) / (df["v"].max()-df["v"].min())
df["w"] = (df["w"]-df["w"].min()) / (df["w"].max()-df["w"].min())

# Plot

X = np.linspace(0,1,101)
Y = np.linspace(0,1,10)
Z = np.linspace(0,1,101)

# Points from which the streamtubes should originate
xpos,ypos = np.meshgrid(X[::5],Y, indexing="xy")
xpos = xpos.reshape(1,-1)[0]
ypos = ypos.reshape(1,-1)[0]


# Streamtube Plot

data_plot = [go.Streamtube(
    x = df['x'],
    y = df['y'],
    z = df['z'],
    u = df['u'],
    v = df['v'],
    w = df['w'],
    starts = dict(                           #Determines the streamtubes starting position.
          x=xpos,
          y=ypos,
          z=[0]*len(xpos)
    ),
    #sizeref = 0.3,
    colorscale = 'jet',
    showscale = True,
    maxdisplayed = 300                      #Determines the maximum segments displayed in a streamtube.
)]

fig = go.Figure(data=data_plot)
fig.show()

Data

As for the data itself:

It is created from 10 slices (y-direction). For each slice (y), [u,v,w] on a regular xz mesh (101x101) was computed. The whole was then assembled into the dataframe which you can download, and which has 101x101x10 data points.

Edit 2

It may be that I am wrongly converting my original data (download here: https://filebin.net/tlgkz3fy1h3j6h5o) into the format suitable for plotly, hence I was wondering if you know how this can be done correctly?

Here some code to visualize the data in a 3D vector plot correctly:

# %% 
import pickle
import numpy as np
import matplotlib.pyplot as plt



# Import Full Data
with open("full_data.pickle", 'rb') as handle:
    full_data = pickle.load(handle)

# Axis
X = np.linspace(0,1,101)
Y = np.linspace(0,1,10)
Z = np.linspace(-500,200,101)

# Initialize List of all fiels
DX = []
DY = []
DZ = []

for cross_section in list(full_data["cross_sections"].keys()):
    
    # extract field components in x, y, and z 
    dx,dy,dz = full_data["cross_sections"][cross_section]
    
    # Make them numpy imediatley
    dx = np.array(dx)
    dy = np.array(dy)
    dz = np.array(dz)
    
    # Apppend
    DX.append(dx)
    DY.append(dy)
    DZ.append(dz)

#Convert to numpy

DX = np.array(DX)
DY = np.array(DY)
DZ = np.array(DZ)
    
    
# Create 3D Quiver Plot with color gradient
# Source: https://stackoverflow.com/questions/65254887/how-to-plot-with-matplotlib-a-3d-quiver-plot-with-color-gradient-for-length-giv
def plot_3d_quiver(x, y, z, u, v, w):
    # COMPUTE LENGTH OF VECTOR -> MAGNITUDE
    c = np.sqrt(np.abs(v) ** 2 + np.abs(u) ** 2 + np.abs(w) ** 2)
    
    c = (c.ravel() - c.min()) / c.ptp()
    # Repeat for each body line and two head lines
    c = np.concatenate((c, np.repeat(c, 2)))
    # Colormap
    c = plt.cm.jet(c)

    fig = plt.figure(dpi =300)
    ax = fig.gca(projection='3d')
    ax.quiver(x, y, z, u, v, w, colors=c, length=0.2, arrow_length_ratio=0.7)
    plt.gca().invert_zaxis()
    plt.show()
    


# Create Mesh !
xi, yi, zi = np.meshgrid(X, Y, Z, indexing='xy')
skip_every = 5
skip_slice = 2
skip3D=(slice(None,None,skip_slice),slice(None,None,skip_every),slice(None,None,skip_every))

# Source: https://stackoverflow.com/questions/68690442/python-plotting-3d-vector-field

plot_3d_quiver(xi[skip3D], yi[skip3D], zi[skip3D]/1000, DX[skip3D], DY[skip3D], 
                np.moveaxis(DZ[skip3D],2,1))

As you can see there are some long downward vectors in the middle of the 3D space, which is not shown in the plotly tubes.

Edit 3

Using the code from the answer, I get this:

This is a huge improvement. This looks almost perfect and is in accordance to what I expect.

A few more questions:

Is there a way to also show some tubes at the lower part of the plot?
Is there a way to flip the z-axis, such that the tubes are coming down from -z to +z (like shown in the cross-section streamline plot) ?
How does the data need to be structured to be organized correctly for the plotly plot? I ask that because of the use of np.moveaxis()?

S.Khajeh · Accepted Answer

I have rewritten my answer to reflect the history of conversation but in a disciplined manner.

The situation is:

len(np.unique(df['x']))
>>> 101

that when compared with:

len(np.unique(df['y']))
>>> 10

Seems data in y-direction are much coarser than that of x-direction!

But in z-direction the situation is even worse because the range of data are way more than that of x and y:

df.min()
>>> x      0.000000
    y      0.000000
    z   -500.000000
    u     -0.369106
    v     -0.259156
    w     -0.517652

df.max()
>>> x      1.000000
    y      1.000000
    z    200.000000
    u      0.368312
    v      0.238271
    w      1.257869

The solution to the ill formed data-set comprises of three steps:

Normalize the vector field and sample points in each direction
Either reduce data density in x and z direction or increase density of data on y-axis.(This step is optional but generally recommended)
After making a plot based on the new data, change axis ticks to the real values.

To normalize a vector-field in this situation which apparently is an engineering one, it's important to maintain the relative length of vectors on every spacial point by doing it this way:

# NORMALIZE VECTOR FIELD -> between [0,1]
np_df = np.array([u, v, w])
vecf_norm = np.linalg.norm(np_df, 2, axis=0)
max_norm = np.max(vecf_norm)
min_norm = np.min(vecf_norm)

u = u * (vecf_norm - min_norm) / (max_norm - min_norm)
v = v * (vecf_norm - min_norm) / (max_norm - min_norm)
w = w * (vecf_norm - min_norm) / (max_norm - min_norm)

As you will see at the end, this formulation will be used to enhance the resulting tube-plot.

Please let me add some important details about using dimensionless data for engineering data visualisation:

First of all if this vector field is resulted from any sort of differential equations, it is highly recommended to reformulate your P.D.F. to a dimensionless equation before attempting to solve it numerically.
If the vector field is result of an already dimensionless differential equation, you need to plot it using dimensionless data (including geometry and u,v,w values).
Please consider plotly uses the local divergence values to determine the local diameter of the tubes. When changing the vector field (and the geometry) we are changing the divergence as well.

I tried to mix your initial and second codes to get this:

import plotly.graph_objs as go
import plotly.express as px
import pandas as pd
import numpy as np
import plotly.io as pio
import pickle

pio.renderers.default='browser'

# Import Full Data
with open("full_data.pickle", 'rb') as handle:
    full_data = pickle.load(handle)

# Axis
X = np.linspace(0,1,101)
Y = np.linspace(0,1,10)
Z = np.linspace(-0.5,0.2,101)

xpos,ypos = np.meshgrid(X[::5],Y, indexing="ij")
#xpos = xpos.reshape(1,-1)[0]
#ypos = ypos.reshape(1,-1)[0]
xpos = np.ravel(xpos)
ypos = np.ravel(ypos)
# Initialize List of all fields
DX = []
DY = []
DZ = []

for cross_section in list(full_data["cross_sections"]):
                
    # extract field components in x, y, and z 
    dx,dy,dz = full_data["cross_sections"][cross_section]

    # Make them numpy imediatley
    dx = np.array(dx)
    dy = np.array(dy)
    dz = np.array(dz)

    # Apppend
    DX.append(dx)
    DY.append(dy)
    DZ.append(dz)

#Convert to numpy
move_i = [0, 1, 2]
move_e = [1, 2, 0]
DX = np.moveaxis(np.array(DX), move_i, move_e)
DY = np.moveaxis(np.array(DY), move_i, move_e)
DZ = np.moveaxis(np.array(DZ), move_i, move_e)

# Create Mesh !
xi, yi, zi = np.meshgrid(X, Y, Z, indexing="ij")


data_plot = [go.Streamtube(
    x = np.ravel(xi),
    y = np.ravel(yi),
    z = np.ravel(zi),
    u = np.ravel(DX),
    v = np.ravel(DY),
    w = np.ravel(DZ),
    starts = dict(                           #Determines the streamtubes starting position.
        x=xpos,
        y=ypos,
        z=np.array([-0.5]*len(xpos)
        )),
    #sizeref = 0.3,
    colorscale = 'jet',
    showscale = True,
    maxdisplayed = 300                      #Determines the maximum segments displayed in a streamtube.
    )]

fig = go.Figure(data=data_plot)
fig.show()

In this code I have removed the skipping thing, because I suspect the evil is happening there. The resulting plot which you have added to your question, seems similar to the 2D plot of your question, but it requires more work to have better result.

So using what have been told already in addition to the info below:

Yes, Tubes are started from the start points, so you need to define start points where you expect to see tubes there! but, the start points need to be geometrically inside the space defined by sample points, otherwise maybe plotly be forced to extrapolate data (I'm not sure about this) and it results in distorted and unexpected results. This means you can define start points both in upper and lower planes of the field to ensure that you have vectors which emit on both planes. Sometime the vectors are there but you can not see them because they are drawn too thin to see. It's because their local divergences are too low, may be if you normalize this vector field by the rules mentioned earlier, it gives you a better result.
According to plotly documentation:

You can tell plotly's automatic axis range calculation logic to reverse the direction of an axis by setting the autorange axis property to "reversed"

plotly reads data point-by-point, so the order of points doesn't really matter but in case of your problem, the issue happens when data became corrupted and disturbed during omitting of some of sample points. i.e. some of x,y,z and some of u,v,w data loosed their correct location which resulted in an entirely different unexpected data set.

I have tried to normalize the (u,v,w) vector-field(using the formulation provided earlier):

import plotly.graph_objs as go
import plotly.express as px
import pandas as pd
import numpy as np
import plotly.io as pio
import pickle

pio.renderers.default='browser'



# Import Full Data
with open("full_data.pickle", 'rb') as handle:
    full_data = pickle.load(handle)

# Axis
X = np.linspace(0,1,101)
Y = np.linspace(0,1,10)
Z = np.linspace(-0.5,0.2,101)

xpos,ypos = np.meshgrid(X[::5],Y, indexing="ij")
#xpos = xpos.reshape(1,-1)[0]
#ypos = ypos.reshape(1,-1)[0]
xpos = np.ravel(xpos)
ypos = np.ravel(ypos)
# Initialize List of all fields
DX = []
DY = []
DZ = []

for cross_section in list(full_data["cross_sections"]):
                
    # extract field components in x, y, and z 
    dx,dy,dz = full_data["cross_sections"][cross_section]

    # Make them numpy imediatley
    dx = np.array(dx)
    dy = np.array(dy)
    dz = np.array(dz)

    # Apppend
    DX.append(dx)
    DY.append(dy)
    DZ.append(dz)

#Convert to numpy
move_i = [0, 1, 2]
move_e = [1, 2, 0]
DX = np.moveaxis(np.array(DX), move_i, move_e)
DY = np.moveaxis(np.array(DY), move_i, move_e)
DZ = np.moveaxis(np.array(DZ), move_i, move_e)

u1 = np.ravel(DX)
v1 = np.ravel(DY)
w1 = np.ravel(DZ)

np_df = np.array([u1, v1, w1])
vecf_norm = np.linalg.norm(np_df, 2, axis=0)
max_norm = np.max(vecf_norm)
min_norm = np.min(vecf_norm)

u2 = u1 * (vecf_norm - min_norm) / (max_norm - min_norm)
v2 = v1 * (vecf_norm - min_norm) / (max_norm - min_norm)
w2 = w1 * (vecf_norm - min_norm) / (max_norm - min_norm)

# Create Mesh !
xi, yi, zi = np.meshgrid(X, Y, Z, indexing="ij")


data_plot = [go.Streamtube(
    x = np.ravel(xi),
    y = np.ravel(yi),
    z = np.ravel(zi),
    u = u2,
    v = v2,
    w = w2,
    starts = dict(                           #Determines the streamtubes starting position.
        x=xpos,
        y=ypos,
        z=np.array([-0.5]*len(xpos)
        )),
    #sizeref = 0.3,
    colorscale = 'jet',
    showscale = True,
    maxdisplayed = 300                      #Determines the maximum segments displayed in a streamtube.
    )]

fig = go.Figure(data=data_plot)
fig.show()

and get a better plot: