Matplotlib -3D 数据可视化

Question

here is example of one txt file

My experiment measurements are in several txt files (in reality I will have hundreds of files, but to demonstrate the idea of plotting, here I only list out 3 files, they are d_401.txt, d_402.txt, d_403.txt) each file has 4 columns & 256 rows of data. (only the first & forth column are the data I need for x and z)

I want to plot a 3D surface plot/or contour plot out of these files. In My 3D plot, x-axis is universally the 1st column data from each file, z-axis is the 4th column data from each file (z value also needs to be color-coded in gradient), and finally y-axis is "line-up in y direction" of all the xz values plot from these three files.

How to generate the python code for this plot? I'm especially confused how to assign the matrix Z, would greatly appreciate if somebody could help me on this issue...I need to have the figure plotted soon.

I attached my pre-mature (supposedly full of error code)

Thanks a million!!!

import numpy as np
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

z_txt = np.array(['d_401.txt', 'd_402.txt', 'd_403.txt'])

zarray = np.zeros([z_txt.size])
y = np.arange(3)
x = np.zeros(256)
Z = np.zeros((len(y),len(x)))


for i in range(z_txt.size):
    zarray[i] = np.loadtxt(z_txt[i])
    x[i] = zarray[i,0]
    X, Y = np.meshgrid(x,y)
    Z[i] = zarray[i,3]
ax.plot_surface(X, Y, Z, cmap=cm.magma, shade=True, lw=3)

plt.show()

Answer 1

The following in the hypotesis that all the files contain the same vector of x …

In [146]: import numpy as np
     ...: import matplotlib.pyplot as plt
     ...: from matplotlib.cm import ScalarMappable as sm
     ...: from glob import glob
     ...: 
     ...: # create fake data and put it in files
     ...: x0, y0 = np.arange(11.0), np.arange(3)+1.0
     ...: z0 = x0+y0[:,None]
     ...: for i in range(3):
     ...:     with open('delendo%d'%(i+1), 'w') as out:
     ...:         for x0z0 in zip(x0, x0+x0, x0-x0, z0[i]):
     ...:             print(*x0z0, sep='\t', file=out)
     ...: 
     ...: # sorted list of "interesting" files
     ...: files = sorted(glob('delendo*'))
     ...: 
     ...: # read the matrix of z values
     ...: Z = np.array([np.loadtxt(f, usecols=3) for f in files])
     ...: # read the vector of x values (the same for all files, I hope so!)
     ...: x = np.loadtxt(files[0], usecols=0)
     ...: # we have as many y's as rows in Z, and we count from 1
     ...: y = np.arange(Z.shape[0])+1
     ...: 
     ...: # prepare for a 3D plot and plot as a surface
     ...: fig, ax = plt.subplots(constrained_layout=1,
     ...:                        subplot_kw={"projection" : "3d"})
     ...: surf = ax.plot_surface(*np.meshgrid(x,y), Z, cmap='magma')
     ...: norm = plt.Normalize(*surf.get_clim())
     ...: plt.colorbar(sm(norm=norm, cmap='magma'))
     ...: plt.show()

---

Addendum

to address some questions raised in comment from OP

You ask about the *sequence operator. It is the unpack operator, that can be used either in an assignment or in an expression. Let's see

>>> tup = (1,2,3,4,5)
>>> a = tup ; print(a)
(1, 2, 3, 4, 5)
>>> a, b = tup
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

But if you use the unpack operator

>>> a, *b = tup ; print(a, b)
1 [2, 3, 4, 5]

Python understand that b is a sequence and stores in this sequence the remaining elements of tup — incidentally, b is a list not a tuple.

The unpack operator can be used in the middle of a left member, but just once because Python assign to the starred item what is left , and two starred items lead to ambiguity.

>>> a,*b, c = tup ; print(a, b, c)
1 [2, 3, 4] 5
>>> a,*b, *c = tup ; print(a, b, c)
  File "<stdin>", line 1
SyntaxError: multiple starred expressions in assignment

Now, let's see the unpack operator at work in an expression

>>> print(*b)
2 3 4 

using the starred syntax the list is unpacked, it's like

>>> print(b[0], b[1], b[2])
2 3 4

Now, coming to your question, you have already used unpacking in your code. even if you possibly was not aware of it…

    X, Y = np.meshgrid(x,y)

Coming to my code

surf = ax.plot_surface(*np.meshgrid(x,y), Z, cmap='magma')

at this point it should be clear, we are unpacking what is returned by meshgrid , it's like X, Y = meshgrid(...) ; surf = ...(X, Y, Z, ...) X, Y = meshgrid(...) ; surf = ...(X, Y, Z, ...) with the (small) advantage that the grid arrays ( X, Y ) are not referenced and the memory they use can be immediately given back to the interpreter.

With respect to your last point, to create a colorbar Matplotlib needs what is called a scalar mappable (sm) and plt.colorbar can check the active Axes to see if there is a sm hanging around.
Many Artists (the software agents that draw into the Axes) like eg, imshow create a sm and all is well, but plot_surface won't, so the poor programmer has to provide a hand-made sm to colorbar .
To specify a sm we need ① a norm and ② a colormap.
The norm is the default, ie, plt.Normalize , we need the limits of Z and these are the value of surf.get_clim() , again I used the starred syntax to unpack the two values.

The length of this explanation is a justification for having it omitted in the first place…