triangular | ruby library for reading | 3D Printing library

Before you do anything else, rotate those credentials. Editing them out of your question is not enough. You have published them online and they are forever compromised.

The whole point of using getenv() for credentials is so you don't have to include them in your source code. The argument to getenv() shouldn't be your database URL; it should be the name of an environment variable that contains your database URL.

The ClearDB add-on sets such a variable for you: CLEARDB_DATABASE_URL.

You mistyped * as + in the for-loop, hence the error. This is the fix:

I created the same result with a negative margin. So the triangles don't have to move an increasing space to the left.

I am no expert in the matter so read with prejudice. Also sorry this is more of a comment than answer...

First You should clarify some things:

• the mesh is convex or concave?
• are the path always on surface or can fly between faces on the outside (if concave) but never inside?
• are the start/end points on edges of faces or can be inside?

Assuming concave, points on edges and only surface paths...

I think the graph A* approach is unusable as there is infinite possible paths between point and any edge of the same face so how you test all of them?

If you really want A* then you can do something similar to raster A*

1. so resample all your edges to more points

   so either n points or use some density like 10 points per average edge length or some detail size.

2. use graph A* on resampled points (do not handle them as edges anymore)

However this will produce only close to shortest path so in order to improve the accuracy you should recursively resample the edges near used point with higher and higher density until the distance between resampled points get smaller than accuracy.

Another option would be using something similar to CCD (cyclic coordinate descent) so:

1. create plane that goes through your 2 points and center of your mesh
2. create path that goes through all intersection of plane and faces between the 2 points (use the shorter on from the 2 options)
3. iterativelly move intersections back and forward and use greedy approach to get the result

However this might get stuck in local minima... You could use search/fitting approaches instead but those will get very slow with increasing number of faces

I got the feeling you might also do this using RANSAC ...

From my point of view I think the first A* approach is the most promising, you just need linked list of points per each edge and one cost counter per each its point from this you can simply encode even the recursive improvement of accuracy. It can be done even in-place so no reallocation needed in the recursion ... And also the algo is not complicated so you should have no problems implementing it, and the result is guaranteed which is not the case with other approaches I mention... Another pros is that it can be used even if start/endpoint does not belong to edge...

Accessing both halves by (i,j) is essentially not how .selfadjointView<>() is intended to work. Supporting that would require a min/max operation and for complex matrices even some kind of proxy-object, for each access which is quite expensive.

You should only access the upper half by the () operator and afterwards you can use the SelfadjointView object as part of other expressions, such as products, or use special methods like rankUpdate.

Make a triangle then position that by position: absolute. more explanation in code:

Just filter out the 0 values as below

The value insertions are in column order (in matrix, data.frame). We may assign on the lower.tri and then get the transpose

You don't have to provide the indices of the triangles: by default, matplotlib can automatically generate them using a Delaunay triangulation (see the documentation), and this should be sufficient for your data.