ssb-sgis 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

sgis/maps/map.py

@@ -83,8 +83,7 @@ class Map:
         scheme: str = DEFAULT_SCHEME,
         **kwargs,
     ):
-        if not all(isinstance(gdf, GeoDataFrame) for gdf in gdfs):
-            gdfs, column = self._separate_args(gdfs, column)
+        gdfs, column, kwargs = self._separate_args(gdfs, column, kwargs)
 
         self._column = column
         self.bins = bins
@@ -139,10 +138,10 @@ class Map:
             self.show.append(show)
         self.labels = new_labels
 
-        if self.show:
+        if len(self._gdfs):
             last_show = self.show[-1]
         else:
-            last_show = True
+            last_show = show
 
         # pop all geometry-like items from kwargs into self._gdfs
         self.kwargs = {}
@@ -296,9 +295,17 @@ class Map:
     def _separate_args(
         args: tuple,
         column: str | None,
+        kwargs: dict,
     ) -> tuple[tuple[GeoDataFrame], str]:
         """Separate GeoDataFrames from string (column argument)."""
 
+        def as_dict(obj):
+            if hasattr(obj, "__dict__"):
+                return obj.__dict__
+            elif isinstance(obj, dict):
+                return obj
+            raise TypeError
+
         gdfs: tuple[GeoDataFrame] = ()
         for arg in args:
             if isinstance(arg, str):
@@ -310,8 +317,27 @@ class Map:
                     )
             elif isinstance(arg, (GeoDataFrame, GeoSeries, Geometry)):
                 gdfs = gdfs + (arg,)
-
-        return gdfs, column
+            elif isinstance(arg, dict) or hasattr(arg, "__dict__"):
+                # add dicts or classes with GeoDataFrames to kwargs
+                more_gdfs = {}
+                for key, value in as_dict(arg).items():
+                    if isinstance(value, (GeoDataFrame, GeoSeries, Geometry)):
+                        more_gdfs[key] = value
+                    elif isinstance(value, dict) or hasattr(value, "__dict__"):
+                        try:
+                            # same as above, one level down
+                            more_gdfs |= {
+                                k: v
+                                for k, v in value.items()
+                                if isinstance(v, (GeoDataFrame, GeoSeries, Geometry))
+                            }
+                        except Exception:
+                            # no need to raise here
+                            pass
+
+                kwargs |= more_gdfs
+
+        return gdfs, column, kwargs
 
     def _prepare_continous_map(self):
         """Create bins if not already done and adjust k if needed."""

sgis/maps/maps.py

@@ -56,7 +56,7 @@ def _get_location_mask(kwargs: dict, gdfs) -> tuple[GeoDataFrame | None, dict]:
 
 
 def explore(
-    *gdfs: GeoDataFrame,
+    *gdfs: GeoDataFrame | dict[str, GeoDataFrame],
     column: str | None = None,
     center: Any | None = None,
     labels: tuple[str] | None = None,
@@ -121,6 +121,8 @@ def explore(
     >>> explore(roads, points, column="meters", cmap="plasma", max_zoom=60)
     """
 
+    gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
+
     loc_mask, kwargs = _get_location_mask(kwargs | {"size": size}, gdfs)
 
     kwargs.pop("size", None)
@@ -145,7 +147,11 @@ def explore(
         elif isinstance(center, GeoDataFrame):
             mask = center
         else:
-            mask = to_gdf_func(center, crs=gdfs[0].crs)
+            try:
+                mask = to_gdf_func(center, crs=gdfs[0].crs)
+            except IndexError:
+                df = [x for x in kwargs.values() if hasattr(x, "crs")][0]
+                mask = to_gdf_func(center, crs=df.crs)
 
         if get_geom_type(mask) in ["point", "line"]:
             mask = mask.buffer(size)
@@ -176,7 +182,7 @@ def explore(
     if not kwargs.pop("explore", True):
         return qtm(m._gdf, column=m.column, cmap=m._cmap, k=m.k)
 
-    m.explore()
+    return m.explore()
 
 
 def samplemap(
@@ -251,20 +257,11 @@ def samplemap(
     if gdfs and isinstance(gdfs[-1], (float, int)):
         *gdfs, size = gdfs
 
+    gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
+
     mask, kwargs = _get_location_mask(kwargs | {"size": size}, gdfs)
     kwargs.pop("size")
 
-    if mask is not None:
-        gdfs, column = Explore._separate_args(gdfs, column)
-        gdfs, kwargs = _prepare_clipmap(
-            *gdfs,
-            mask=mask,
-            labels=labels,
-            **kwargs,
-        )
-        if not gdfs:
-            return
-
     if explore:
         m = Explore(
             *gdfs,
@@ -277,6 +274,12 @@ def samplemap(
         )
         if m.gdfs is None:
             return
+        if mask is not None:
+            m._gdfs = [gdf.clip(mask) for gdf in m._gdfs]
+            m._gdf = m._gdf.clip(mask)
+            m._nan_idx = m._gdf[m._column].isna()
+            m._get_unique_values()
+
         m.samplemap(size, sample_from_first=sample_from_first)
 
     else:
@@ -311,38 +314,6 @@ def samplemap(
         qtm(m._gdf, column=m.column, cmap=m._cmap, k=m.k)
 
 
-def _prepare_clipmap(*gdfs, mask, labels, **kwargs):
-    if mask is None:
-        mask, kwargs = _get_location_mask(kwargs, gdfs)
-        if mask is None and len(gdfs) > 1:
-            *gdfs, mask = gdfs
-        elif mask is None:
-            raise ValueError("Must speficy mask.")
-
-    # storing object names in dict here, since the names disappear after clip
-    if not labels:
-        namedict = make_namedict(gdfs)
-        kwargs["namedict"] = namedict
-
-    clipped: tuple[GeoDataFrame] = ()
-
-    if mask is not None:
-        for gdf in gdfs:
-            clipped_ = gdf.clip(mask)
-            clipped = clipped + (clipped_,)
-
-    else:
-        for gdf in gdfs[:-1]:
-            clipped_ = gdf.clip(gdfs[-1])
-            clipped = clipped + (clipped_,)
-
-    if not any(len(gdf) for gdf in clipped):
-        warnings.warn("None of the GeoDataFrames are within the mask extent.")
-        return None, None
-
-    return clipped, kwargs
-
-
 def clipmap(
     *gdfs: GeoDataFrame,
     column: str | None = None,
@@ -391,23 +362,18 @@ def clipmap(
     samplemap: same functionality, but shows only a random area of a given size.
     """
 
-    gdfs, column = Explore._separate_args(gdfs, column)
+    gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
 
-    clipped, kwargs = _prepare_clipmap(
-        *gdfs,
-        mask=mask,
-        labels=labels,
-        **kwargs,
-    )
-    if not clipped:
-        return
+    if mask is None and len(gdfs) > 1:
+        mask = gdfs[-1]
+        gdfs = gdfs[:-1]
 
     center = kwargs.pop("center", None)
     size = kwargs.pop("size", None)
 
     if explore:
         m = Explore(
-            *clipped,
+            *gdfs,
             column=column,
             labels=labels,
             browser=browser,
@@ -418,6 +384,10 @@ def clipmap(
         if m.gdfs is None:
             return
 
+        m._gdfs = [gdf.clip(mask) for gdf in m._gdfs]
+        m._gdf = m._gdf.clip(mask)
+        m._nan_idx = m._gdf[m._column].isna()
+        m._get_unique_values()
         m.explore(center=center, size=size)
     else:
         m = Map(
@@ -426,6 +396,14 @@ def clipmap(
             labels=labels,
             **kwargs,
         )
+        if m.gdfs is None:
+            return
+
+        m._gdfs = [gdf.clip(mask) for gdf in m._gdfs]
+        m._gdf = m._gdf.clip(mask)
+        m._nan_idx = m._gdf[m._column].isna()
+        m._get_unique_values()
+
         qtm(m._gdf, column=m.column, cmap=m._cmap, k=m.k)
 
 
@@ -449,8 +427,12 @@ def explore_locals(*gdfs, to_gdf: bool = True, **kwargs):
                 continue
             if not to_gdf:
                 continue
-            if hasattr(value, "__len__") and not len(value):
+            try:
+                if hasattr(value, "__len__") and not len(value):
+                    continue
+            except TypeError:
                 continue
+
             try:
                 gdf = clean_geoms(to_gdf_func(value))
                 if len(gdf):
@@ -509,7 +491,7 @@ def qtm(
     See also:
         ThematicMap: Class with more options for customising the plot.
     """
-    gdfs, column = Explore._separate_args(gdfs, column)
+    gdfs, column, kwargs = Map._separate_args(gdfs, column, kwargs)
 
     new_kwargs = {}
     for key, value in kwargs.items():

sgis/maps/tilesources.py

@@ -0,0 +1,61 @@
+from xyzservices import TileProvider, Bunch, providers
+
+kartverket = Bunch(
+    norgeskart=TileProvider(
+        name="Norgeskart",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=norgeskart_bakgrunn&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    bakgrunnskart_forenklet=TileProvider(
+        name="Norgeskart forenklet",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=bakgrunnskart_forenklet&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    norges_grunnkart=TileProvider(
+        name="Norges grunnkart",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=norges_grunnkart&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    norges_grunnkart_gråtone=TileProvider(
+        name="Norges grunnkart gråtone",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=norges_grunnkart_graatone&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    n50=TileProvider(
+        name="N5 til N50 kartdata",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=kartdata3&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    topogråtone=TileProvider(
+        name="Topografisk norgeskart gråtone",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=topo4graatone&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    toporaster=TileProvider(
+        name="Topografisk raster",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=toporaster4&zoom={z}&x={x}&y={y}",
+        attribution="© Kartverket",
+        html_attribution='&copy; <a href="https://kartverket.no">Kartverket</a>',
+    ),
+
+    norge_i_bilder=TileProvider(
+        name="Norge i bilder",
+        url="https://opencache.statkart.no/gatekeeper/gk/gk.open_nib_web_mercator_wmts_v2?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=Nibcache_web_mercator_v2&STYLE=default&FORMAT=image/jpgpng&tileMatrixSet=default028mm&tileMatrix={z}&tileRow={y}&tileCol={x}",
+        max_zoom=19,
+        attribution="© Geovekst",
+    ),
+)
+
+xyz = Bunch({"Kartverket": kartverket} | providers)

sgis/networkanalysis/closing_network_holes.py

@@ -3,15 +3,63 @@
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame
+from geopandas import GeoDataFrame, GeoSeries
 from pandas import DataFrame
 from shapely import shortest_line
 
-from ..geopandas_tools.conversion import coordinate_array
+from ..geopandas_tools.conversion import coordinate_array, to_geoseries
+from ..geopandas_tools.geometry_types import get_geom_type
 from ..geopandas_tools.neighbors import k_nearest_neighbors
 from .nodes import make_edge_wkt_cols, make_node_ids
 
 
+def close_network_holes_to(
+    lines: GeoDataFrame | GeoSeries,
+    extend_to: GeoDataFrame | GeoSeries,
+    max_distance: int | float,
+    max_angle: int | float,
+) -> GeoDataFrame | GeoSeries:
+    if isinstance(lines, GeoSeries):
+        lines = lines.to_frame("geometry")
+        was_geoseries = True
+    else:
+        was_geoseries = False
+
+    lines, _ = make_node_ids(lines)
+
+    if isinstance(extend_to, GeoSeries):
+        extend_to = extend_to.to_frame("geometry")
+
+    if not (extend_to.geom_type == "Point").all():
+        raise ValueError("'extend_to' must be singlepart point geometries")
+
+    extend_to["wkt"] = extend_to.geometry.to_wkt()
+    extend_to = extend_to.drop_duplicates("wkt")
+    extend_to["node_id"] = range(len(extend_to))
+
+    new_lines: GeoSeries = _close_holes_all_lines(
+        lines, extend_to, max_distance=max_distance, max_angle=max_angle, idx_start=0
+    )
+
+    if was_geoseries:
+        return pd.concat([lines.geometry, new_lines])
+
+    new_lines = gpd.GeoDataFrame(
+        {"geometry": new_lines}, geometry="geometry", crs=lines.crs
+    )
+
+    return pd.concat([lines, new_lines], ignore_index=True).drop(
+        columns=[
+            "source_wkt",
+            "target_wkt",
+            "source",
+            "target",
+            "n_source",
+            "n_target",
+        ]
+    )
+
+
 def close_network_holes(
     gdf: GeoDataFrame,
     max_distance: int | float,
@@ -88,32 +136,42 @@ def close_network_holes(
     intentional. They are road blocks where most cars aren't allowed to pass. Fill the
     holes only if it makes the travel times/routes more realistic.
     """
-    gdf, nodes = make_node_ids(gdf)
 
-    new_lines = _find_holes_all_lines(
-        gdf,
-        nodes,
-        max_distance,
-        max_angle=max_angle,
+    lines, nodes = make_node_ids(gdf)
+
+    # remove duplicates of lines going both directions
+    lines["sorted"] = [
+        "_".join(sorted([s, t]))
+        for s, t in zip(lines["source"], lines["target"], strict=True)
+    ]
+
+    new_lines: GeoSeries = _close_holes_all_lines(
+        lines.drop_duplicates("sorted"), nodes, max_distance, max_angle, idx_start=1
+    )
+
+    new_lines = gpd.GeoDataFrame(
+        {"geometry": new_lines}, geometry="geometry", crs=gdf.crs
     )
 
     if not len(new_lines):
-        gdf[hole_col] = 0 if hole_col not in gdf.columns else gdf[hole_col].fillna(0)
-        return gdf
+        lines[hole_col] = (
+            0 if hole_col not in lines.columns else lines[hole_col].fillna(0)
+        )
+        return lines
 
     new_lines = make_edge_wkt_cols(new_lines)
 
-    wkt_id_dict = {
-        wkt: id for wkt, id in zip(nodes["wkt"], nodes["node_id"], strict=True)
-    }
+    wkt_id_dict = dict(zip(nodes["wkt"], nodes["node_id"], strict=True))
     new_lines["source"] = new_lines["source_wkt"].map(wkt_id_dict)
     new_lines["target"] = new_lines["target_wkt"].map(wkt_id_dict)
 
     if hole_col:
         new_lines[hole_col] = 1
-        gdf[hole_col] = 0 if hole_col not in gdf.columns else gdf[hole_col].fillna(0)
+        lines[hole_col] = (
+            0 if hole_col not in lines.columns else lines[hole_col].fillna(0)
+        )
 
-    return pd.concat([gdf, new_lines], ignore_index=True)
+    return pd.concat([lines, new_lines], ignore_index=True)
 
 
 def get_angle(array_a, array_b):
@@ -200,49 +258,29 @@ def close_network_holes_to_deadends(
     return pd.concat([gdf, new_lines], ignore_index=True)
 
 
-def _find_holes_all_lines(
-    lines: GeoDataFrame,
-    nodes: GeoDataFrame,
-    max_distance: int | float,
-    max_angle: int,
-) -> GeoDataFrame | DataFrame:
-    """Creates lines between deadends and closest node.
-
-    Creates lines if distance is less than max_distance and angle less than max_angle.
-
-    wkt: well-known text, e.g. "POINT (60 10)"
-    """
-    k = 50 if len(nodes) >= 50 else len(nodes)
-    crs = nodes.crs
-
-    # remove duplicates of lines going both directions
-    lines["sorted"] = [
-        "_".join(sorted([s, t]))
-        for s, t in zip(lines["source"], lines["target"], strict=True)
-    ]
-
-    no_dups = lines.drop_duplicates("sorted")
-
-    no_dups, nodes = make_node_ids(no_dups)
+def _close_holes_all_lines(
+    lines, nodes, max_distance, max_angle, idx_start: int
+) -> GeoSeries:
+    k = min(len(nodes), 50)
 
     # make point gdf for the deadends and the other endpoint of the deadend lines
-    deadends_target = no_dups.loc[no_dups.n_target == 1].rename(
+    deadends_target = lines.loc[lines["n_target"] == 1].rename(
         columns={"target_wkt": "wkt", "source_wkt": "wkt_other_end"}
     )
-    deadends_source = no_dups.loc[no_dups.n_source == 1].rename(
+    deadends_source = lines.loc[lines["n_source"] == 1].rename(
         columns={"source_wkt": "wkt", "target_wkt": "wkt_other_end"}
     )
     deadends = pd.concat([deadends_source, deadends_target], ignore_index=True)
 
     if len(deadends) <= 1:
-        return DataFrame()
+        return GeoSeries()
 
     deadends_other_end = deadends.copy()
     deadends_other_end["geometry"] = gpd.GeoSeries.from_wkt(
-        deadends_other_end["wkt_other_end"], crs=crs
+        deadends_other_end["wkt_other_end"]
     )
 
-    deadends["geometry"] = gpd.GeoSeries.from_wkt(deadends["wkt"], crs=crs)
+    deadends["geometry"] = gpd.GeoSeries.from_wkt(deadends["wkt"])
 
     deadends_array = coordinate_array(deadends)
     nodes_array = coordinate_array(nodes)
@@ -255,7 +293,7 @@ def _find_holes_all_lines(
     # and endpoints of the new lines in lists, looping through the k neighbour points
     new_sources: list[str] = []
     new_targets: list[str] = []
-    for i in np.arange(1, k):
+    for i in np.arange(idx_start, k):
         # to break out of the loop if no new_targets that meet the condition are found
         len_now = len(new_sources)
 
@@ -263,7 +301,7 @@ def _find_holes_all_lines(
         indices = all_indices[:, i]
         dists = all_dists[:, i]
 
-        these_nodes_array = coordinate_array(nodes.loc[indices])
+        these_nodes_array = coordinate_array(nodes.iloc[indices])
 
         if np.all(deadends_other_end_array == these_nodes_array):
             continue
@@ -286,7 +324,7 @@ def _find_holes_all_lines(
 
         from_wkt = deadends.loc[condition, "wkt"]
         to_idx = indices[condition]
-        to_wkt = nodes.loc[to_idx, "wkt"]
+        to_wkt = nodes.iloc[to_idx]["wkt"]
 
         # now add the wkts to the lists of new sources and targets. If the source
         # is already added, the new wks will not be added again
@@ -301,18 +339,10 @@ def _find_holes_all_lines(
         if len_now == len(new_sources):
             break
 
-    # make GeoDataFrame with straight lines
-    new_sources = gpd.GeoSeries.from_wkt(new_sources, crs=crs)
-    new_targets = gpd.GeoSeries.from_wkt(new_targets, crs=crs)
-    new_lines = shortest_line(new_sources, new_targets)
-    new_lines = gpd.GeoDataFrame({"geometry": new_lines}, geometry="geometry", crs=crs)
-
-    if not len(new_lines):
-        return new_lines
-
-    new_lines = make_edge_wkt_cols(new_lines)
-
-    return new_lines
+    # make GeoSeries with straight lines
+    new_sources = gpd.GeoSeries.from_wkt(new_sources, crs=lines.crs)
+    new_targets = gpd.GeoSeries.from_wkt(new_targets, crs=lines.crs)
+    return shortest_line(new_sources, new_targets)
 
 
 def _find_holes_deadends(
@@ -362,7 +392,4 @@ def _find_holes_deadends(
     new_lines = shortest_line(from_geom, to_geom)
     new_lines = gpd.GeoDataFrame({"geometry": new_lines}, geometry="geometry", crs=crs)
 
-    if not len(new_lines):
-        return new_lines
-
     return new_lines

sgis/networkanalysis/cutting_lines.py

@@ -101,7 +101,7 @@ def split_lines_by_nearest_point(
 
     gdf = gdf.copy()
 
-    # move the points to the nearest exact point of the line
+    # move the points to the nearest exact location on the line
     if max_distance:
         snapped = snap_within_distance(points, gdf, max_distance=max_distance)
     else:
@@ -167,12 +167,18 @@ def split_lines_by_nearest_point(
     # the snapped points.
 
     splitted = change_line_endpoint(
-        splitted, dists_source, pointmapper_source, change_what="first"
+        splitted,
+        indices=dists_source.index,
+        pointmapper=pointmapper_source,
+        change_what="first",
     )  # i=0)
 
     # same for the lines where the target was split, but change the last coordinate
     splitted = change_line_endpoint(
-        splitted, dists_target, pointmapper_target, change_what="last"
+        splitted,
+        indices=dists_target.index,
+        pointmapper=pointmapper_target,
+        change_what="last",
     )  # , i=-1)
 
     if splitted_col:
@@ -185,7 +191,7 @@ def split_lines_by_nearest_point(
 
 def change_line_endpoint(
     gdf: GeoDataFrame,
-    dists: pd.DataFrame,
+    indices: pd.Index,
     pointmapper: pd.Series,
     change_what: str | int,
 ) -> GeoDataFrame:
@@ -204,7 +210,7 @@ def change_line_endpoint(
             f"change_what should be 'first' or 'last' or 0 or -1. Got {change_what}"
         )
 
-    is_relevant = gdf.index.isin(dists.index)
+    is_relevant = gdf.index.isin(indices)
     relevant_lines = gdf.loc[is_relevant]
 
     relevant_lines.geometry = extract_unique_points(relevant_lines.geometry)

sgis/networkanalysis/finding_isolated_networks.py

@@ -35,7 +35,7 @@ def get_connected_components(gdf: GeoDataFrame) -> GeoDataFrame:
 
     Removing the isolated network islands.
 
-    >>> connected_roads = get_connected_components(roads).query("connected == 1")
+    >>> connected_roads = get_connected_components(roads).loc[lambda x: x["connected"] == 1]
     >>> roads.connected.value_counts()
     1.0    85638
     Name: connected, dtype: int64

sgis/networkanalysis/nodes.py

@@ -171,7 +171,7 @@ def _prepare_make_edge_cols(
 
     geom_col = lines._geometry_column_name
 
-    # some LinearRings are coded as LineStrings and need to be removed manually
+    # some LineStrings are in fact rings and must be removed manually
     boundary = lines[geom_col].boundary
     circles = boundary.loc[boundary.is_empty]
     lines = lines[~lines.index.isin(circles.index)]

sgis/networkanalysis/traveling_salesman.py

@@ -20,7 +20,8 @@ def traveling_salesman_problem(
         return_to_start: If True (default), the path
             will make a full circle to the startpoint.
             If False, a dummy node will be added to make the
-            salesman focus only on getting to the last node.
+            salesman focus only on getting to the last node. Not
+            guaranteed to work, meaning the wrong edge might be removed.
         distances: Optional DataFrame of distances between all points.
             If not provided, the calculation is done within this function.
             The DataFrame should be identical to the DataFrame created
@@ -75,7 +76,7 @@ def traveling_salesman_problem(
             & (x["neighbor_index"].isin(points.index))
         ]
 
-        # need integer index
+        # need tange integer index
         to_int_idx = {idx: i for i, idx in enumerate(points.index)}
         points.index = points.index.map(to_int_idx)
         points = points.sort_index()
@@ -92,11 +93,12 @@ def traveling_salesman_problem(
         distances = distances.sort_values(
             ["mean_distance", "distance"], ascending=[True, False]
         )
+
         max_dist_idx = distances["mean_distance"].idxmax()
 
         dummy_node_idx = points.index.max() + 1
         n_points = dummy_node_idx + 1
-        max_dist_and_some = distances["distance"].max() * 1.1
+        max_dist_and_some = distances["distance"].sum() * 1.01
 
         # add edges in both directions to the dummy node
         dummy_node = pd.DataFrame(
@@ -152,4 +154,6 @@ def traveling_salesman_problem(
 
     best_path = best_path[idx_start:] + best_path[:idx_start]
 
-    return [idx_to_point[i] for i in best_path if i != dummy_node_idx]
+    as_points = [idx_to_point[i] for i in best_path if i != dummy_node_idx]
+
+    return as_points  # + [as_points[0]]