pyvista | 3D plotting and mesh analysis | Data Visualization library

you have the vtkLogger class to manage your logs (I know, c++ docs but VTK has a lack of python doc).

e.g.:

The convenience functions for your case seem a bit too convenient.

What plot_normals() does under the hood is that it accesses cave.point_normals, which in turn calls cave.compute_normals(). The default arguments to compute_normals() include consistent_normals=True, which according to the docs does

Enforcement of consistent polygon ordering.

There are some other parameters which hint at potential black magic going on when running this filter (e.g. auto_orient_normals and non_manifold_ordering, even though the defaults seem safe).

So what seems to happen is that your mesh (which is non manifold, i.e. it has open edges) breaks the magic that compute_normals tries to do with the default "enforcement of polygon ordering". Since you already enforced the correct order in Blender, you can tell pyvista (well, VTK) to leave your polygons alone and just compute the normals as they are. This is not possible through plot_normals(), so you need a bit more work:

The linear interpolation you're trying to use is a general tool that should work (with one small caveat). So the issue is first with your rectangular edge.

Here's a sanity check which plots your interior and exterior lines:

I'm not familiar with ParaView, but it looks like you want to add vector-valued point data to your mesh. Many of PyVista's examples implicitly do that, but this is also mentioned in the Basic API Usage page of the documentation.

Assuming you have an array called displacements with shape (mesh.n_points, 3) (i.e. one 3-dimensional vector for each point in the mesh) where the vectors are in the same order as the mesh points, you just have to do

As I noted in a comment under a previous version of your question, I can't find an easy way to fix your current approach.

1. You could pass alpha=cloud.length/10 to delaunay_2d() which would be close enough, but this would still leave spurious fringes at the edge of your waveguide.
2. It would be nice to be able to create your waveguide using extrusion, but I don't see how that would be applicable here.

So the only thing I can think of is to change your whole approach: create your waveguide as a 2d structured grid, by parametrising your surface. This is actually possible, and not too difficult:

1. In 2d you have a circle and an ellipse, and linear interpolation between the two. This means taking points in the form of (r*cos(phi), r*sin(phi)) and interpolating to points at (a*cos(phi), b*sin(phi)). This is straightforward.
2. In the z direction you have a root function, which depends on the "radial" coordinate of your 2d grid.

Here's how you can do this:

"(Not Responding)" in Windows is usually the consequence of a deadlock. Historically, a lot of confusion has surfaced over whether to override run() or to use moveToThread() when dealing with QThread:

1. You're doing it wrong...
2. You were not doing so wrong
3. QThread documentation: do not discourage the reimplementation of QThread

Though both methods are accepted, I chose to use moveToThread() because I learned it was best used when you have threads that need to interact with one another through signals and slots (see QThreads: Are You Using Them Wrong?)

After careful consideration, I removed the lambda from self.thread.started.connect and replaced it with

The problem is that scalars for a scalar bar are stored in a dict, with the scalar bar title as the key. When you don't set a scalar bar title yourself, the default of '' is used, see Plotter.add_scalar_bar(). Since both datasets share the same empty string as key, the latter overwrites the former.

The solution is to pass an explicit title for your scalar bars:

I got one solution for this action. as pyvista is base from vtk, i used vtk function and it is working fine. if anyone found better solution, please post.

Just overwrite the points after having created the triangulation with the flat point array: