airy | build streaming apps with real-time data | Chat library

Interesting problem and nice to see sfnetworks being used on other type of networks than road networks! I gave this some thought. Beware, the answer is long and may be complicated sometimes.

It is clear what you want the output of your example to be, but the example does not cover many different possibilities of how the network structure can look like after blending in the given points. Therefore it is hard to generalize the rules that should be used for merging. But I made some assumptions regarding that:

As far as I understand you want to group edges based on what the first point is that you pass when travelling downstream on the river network. Hence, if the paths downstreams (towards the root of the tree) from edge 1 and edge 2 both pass through point 1 before passing any of the other points, they should be in the same group. All edges from which downstream travelling reaches the root without passing through any of the points should be together in a single group as well.

So the ultimate goal is to assign a group index to each of the edges. In tidygraph (the library on which sfnetworks is build), there are several grouping functions that can be applied to either the nodes or edges of the network. Such grouping functions are meant to be used inside tidyverse verbs like mutate() and filter(), where the network that is being worked on is known and not needed as an argument to the grouping function. Hence, you can run network %>% mutate(group = group_components()), without the need to explicitly forward the network as argument to group_components().

All nice and well, but as far as I know tidygraph does not have a grouping function implemented that addresses your problem. That means, we should create our own! I gave it a try. It may not be exactly what you need, but at least it should give you a good starting point to build further on.

The idea is that we first calculate the distances from the nodes that correspond with the points you added to the network, to all nodes in the network. Then, we select for each point a set of nodes such that the travel time from that point to these nodes is lower than from any other point. The edges that connect the nodes in such a set form the group of edges belonging to that point.

I created another example network which covers more possible cases. The first part of the code below is mainly constructing that network. Then we get to writing the custom group function, and finally applying it to my example network, and also to yours.

I will present a solution based on a new R package called sfnetworks. For the moment, it's not on CRAN, but you can install it as follows:

If I understand what you want, you need more XTicks in the x limits mentioned. After you plot just:

This is very bad what are you doing. The Problem is, every time you create a layer you add a new click event to $("#btnPoiFilter").

Change your code to:

You can easy create a global variable:

You need to use regex to pull out the relevant json string

You should declare reflection configuration in your native-image.properties with -H:ReflectionConfigurationFiles=/path/to/reflectconfig

Here is the documentation for doing so

You are getting the error because similarity function does not accept np.float values. So your idea to use .fillna() is in the right direction. However, you have to ensure that all columns are of dtype str/object.

You can do this by

Because of the subject matter, I think we couldn't see the wood for the trees. If we look at the docs for transform you'll see:

• xx (scalar or array (numpy or python)) – Input x coordinate(s).
• yy (scalar or array (numpy or python)) – Input y coordinate(s).

Great; the numpy array is exactly what we need. A pd.DataFrame can be thought of as a dictionary of arrays, so we just need to isolate those columns and pass them to the function. There's a tiny catch - columns of a DataFrame will be a Series, which transform will reject, so we just need to use the values attribute. This mini example is directly equivalent to your initial approach: