manifold | Manifold is a Java compiler plugin, its features include Metaprogramming, Properties, Extension Meth

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...

For this use case, seaborn allows a dictionary as palette. The dictionary will assign a color to each hue value.

Here is an example of how such a dictionary could be created for your data:

Just like any scikit-learn transformer, objects created from class from sklearn.manifold import LocallyLinearEmbedding implement a .fit() and .transform() method. (In your example, StandardScaler is another example of a Transformer). Therefore, to find the embedding space using data from X_train you can do:

I don't actually if it's even possible to do with requests_html, but it is with selenium.

Insert the tailwind class z-10 to the navbar container to give the navbar a higher z-Index

In plotly-python, I don't think there's an easy way of retrieving the location of the cursor. You can attempt to use go.FigureWidget to highlight a trace as described in this answer, but i think you're going to be limited with with plotly-python and i'm not sure if highlighting the closest n points will be possible.

However, I believe that you can accomplish what you want in plotly-dash since callbacks are supported - meaning you would be able to retrieve location of your cursor and then calculate the n closest data points to your cursor and highlight the data points as needed.

Below is an example of such a solution. If you haven't seen it before, it looks complicated, but what is happening is that I am taking the point where you clicked as an input. plotly is plotly.js under the hood so it comes us in the form of a dictionary (and not some kind of plotly-python object). Then I calculate the closest three data points to the clicked input point by comparing the coordinates of every other point in the dataframe, add the information from the three closest points as traces to the input with the color teal (or any color of your choosing), and send this modified input back as the output, and update the figure.

I am using click instead of hover because hover would cause the highlighted points to flicker too much as you drag your mouse through the points.

Also the dash app doesn't work perfectly as I believe there is some issue when you double click on points (you can see me click once in the gif below before getting it to start working), but this basic framework is hopefully close enough to what you want. Cheers!

Maybe filter only pages that have at least one link to details? Here is an example of how to identify if a page meets the criteria you are searching for:

If it is the cluster size, you just need to tabulate the results of your DBSCAN, for example in this dataset:

If you want to select the N best features of your dataset in your Pipelineyou should define a custom Transformer.

This object should train and select the N best feature from xgboost during the transform() method. Then During the transform() method, this transformer should filter your dataset accordingly.

I would do as follows: