geo-activity-playground 0.10.0__tar.gz → 0.11.0__tar.gz

{geo_activity_playground-0.10.0 → geo_activity_playground-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.10.0
+Version: 0.11.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
@@ -26,7 +26,6 @@ Requires-Dist: pandas (>=2.0,<3.0)
 Requires-Dist: pyarrow (>=12.0.1,<13.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
-Requires-Dist: scikit-learn (>=1.3.0,<2.0.0)
 Requires-Dist: scipy (>=1.8.1,<2.0.0)
 Requires-Dist: stravalib (>=1.3.3,<2.0.0)
 Requires-Dist: tcxreader (>=0.4.5,<0.5.0)

{geo_activity_playground-0.10.0 → geo_activity_playground-0.11.0}/geo_activity_playground/core/activities.py

@@ -59,14 +59,15 @@ class ActivityRepository:
             df["time"] = [start + datetime.timedelta(seconds=t) for t in time]
         assert pd.api.types.is_dtype_equal(df["time"].dtype, "datetime64[ns, UTC]")
 
-        df["distance/km"] = df["distance"] / 1000
-
-        if "speed" not in df.columns:
-            df["speed"] = (
-                df["distance"].diff()
-                / (df["time"].diff().dt.total_seconds() + 1e-3)
-                * 3.6
-            )
+        if "distance" in df.columns:
+            df["distance/km"] = df["distance"] / 1000
+
+            if "speed" not in df.columns:
+                df["speed"] = (
+                    df["distance"].diff()
+                    / (df["time"].diff().dt.total_seconds() + 1e-3)
+                    * 3.6
+                )
 
         return df
 

geo_activity_playground-0.11.0/geo_activity_playground/core/heatmap.py

@@ -0,0 +1,292 @@
+"""
+This code is based on https://github.com/remisalmon/Strava-local-heatmap.
+"""
+import dataclasses
+import functools
+import logging
+import pathlib
+
+import matplotlib.pyplot as pl
+import numpy as np
+import pandas as pd
+
+from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.tasks import work_tracker
+from geo_activity_playground.core.tiles import get_tile
+from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
+from geo_activity_playground.core.tiles import latlon_to_xy
+
+
+logger = logging.getLogger(__name__)
+
+
+@functools.cache
+def get_all_points(repository: ActivityRepository) -> pd.DataFrame:
+    logger.info("Gathering all points …")
+    all_points_path = pathlib.Path("Cache/all_points.parquet")
+    if all_points_path.exists():
+        all_points = pd.read_parquet(all_points_path)
+    else:
+        all_points = pd.DataFrame()
+    new_shards = []
+    with work_tracker(pathlib.Path("Cache/task_all_points.json")) as tracker:
+        for activity in repository.iter_activities():
+            if activity.id in tracker:
+                continue
+            tracker.add(activity.id)
+
+            logger.info(f"Parsing points from {activity.id} …")
+            time_series = repository.get_time_series(activity.id)
+            if len(time_series) == 0 or "latitude" not in time_series.columns:
+                continue
+            new_shards.append(time_series[["latitude", "longitude"]])
+    logger.info("Concatenating shards …")
+    all_points = pd.concat([all_points] + new_shards)
+    all_points.to_parquet(all_points_path)
+    return all_points
+
+
+@dataclasses.dataclass
+class GeoBounds:
+    lat_min: float
+    lon_min: float
+    lat_max: float
+    lon_max: float
+
+
+def get_bounds(lat_lon_data: np.array) -> GeoBounds:
+    return GeoBounds(*np.min(lat_lon_data, axis=0), *np.max(lat_lon_data, axis=0))
+
+
+def add_margin(lower: float, upper: float) -> tuple[float, float]:
+    spread = upper - lower
+    margin = spread / 20
+    return max(0, lower - margin), upper + margin
+
+
+def add_margin_to_geo_bounds(bounds: GeoBounds) -> GeoBounds:
+    lat_min, lat_max = add_margin(bounds.lat_min, bounds.lat_max)
+    lon_min, lon_max = add_margin(bounds.lon_min, bounds.lon_max)
+    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
+
+
+OSM_TILE_SIZE = 256  # OSM tile size in pixel
+OSM_MAX_ZOOM = 19  # OSM maximum zoom level
+MAX_TILE_COUNT = 2000  # maximum number of tiles to download
+
+
+@dataclasses.dataclass
+class TileBounds:
+    zoom: int
+    x_tile_min: int
+    x_tile_max: int
+    y_tile_min: int
+    y_tile_max: int
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return (
+            (self.y_tile_max - self.y_tile_min) * OSM_TILE_SIZE,
+            (self.x_tile_max - self.x_tile_min) * OSM_TILE_SIZE,
+        )
+
+
+def geo_bounds_from_tile_bounds(tile_bounds: TileBounds) -> GeoBounds:
+    lat_max, lon_min = get_tile_upper_left_lat_lon(
+        tile_bounds.x_tile_min, tile_bounds.y_tile_min, tile_bounds.zoom
+    )
+    lat_min, lon_max = get_tile_upper_left_lat_lon(
+        tile_bounds.x_tile_max, tile_bounds.y_tile_max, tile_bounds.zoom
+    )
+    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
+
+
+def get_sensible_zoom_level(
+    bounds: GeoBounds, picture_size: tuple[int, int]
+) -> TileBounds:
+    zoom = OSM_MAX_ZOOM
+
+    while True:
+        x_tile_min, y_tile_max = map(
+            int, latlon_to_xy(bounds.lat_min, bounds.lon_min, zoom)
+        )
+        x_tile_max, y_tile_min = map(
+            int, latlon_to_xy(bounds.lat_max, bounds.lon_max, zoom)
+        )
+
+        x_tile_max += 1
+        y_tile_max += 1
+
+        if (x_tile_max - x_tile_min) * OSM_TILE_SIZE <= picture_size[0] and (
+            y_tile_max - y_tile_min
+        ) * OSM_TILE_SIZE <= picture_size[1]:
+            break
+
+        zoom -= 1
+
+    tile_count = (x_tile_max - x_tile_min) * (y_tile_max - y_tile_min)
+
+    if tile_count > MAX_TILE_COUNT:
+        raise RuntimeError("Zoom value too high, too many tiles to download")
+
+    return TileBounds(
+        zoom=zoom,
+        x_tile_min=x_tile_min,
+        x_tile_max=x_tile_max,
+        y_tile_min=y_tile_min,
+        y_tile_max=y_tile_max,
+    )
+
+
+def build_map_from_tiles(tile_bounds: TileBounds) -> np.array:
+    background = np.zeros((*tile_bounds.shape, 3))
+
+    for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
+        for y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
+            tile = np.array(get_tile(tile_bounds.zoom, x, y)) / 255
+
+            i = y - tile_bounds.y_tile_min
+            j = x - tile_bounds.x_tile_min
+
+            background[
+                i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
+                j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
+                :,
+            ] = tile[:, :, :3]
+
+    return background
+
+
+def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
+    image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
+    image = np.dstack((image, image, image))
+    return image
+
+
+def crop_image_to_bounds(
+    image: np.ndarray, geo_bounds: GeoBounds, tile_bounds: TileBounds
+) -> np.ndarray:
+    min_x, min_y = latlon_to_xy(
+        geo_bounds.lat_max, geo_bounds.lon_min, tile_bounds.zoom
+    )
+    max_x, max_y = latlon_to_xy(
+        geo_bounds.lat_min, geo_bounds.lon_max, tile_bounds.zoom
+    )
+    min_x = int((min_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE)
+    min_y = int((min_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE)
+    max_x = int((max_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE)
+    max_y = int((max_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE)
+    image = image[min_y:max_y, min_x:max_x, :]
+    return image
+
+
+def gaussian_filter(image, sigma):
+    # returns image filtered with a gaussian function of variance sigma**2
+    #
+    # input: image = numpy.ndarray
+    #        sigma = float
+    # output: image = numpy.ndarray
+
+    i, j = np.meshgrid(
+        np.arange(image.shape[0]), np.arange(image.shape[1]), indexing="ij"
+    )
+
+    mu = (int(image.shape[0] / 2.0), int(image.shape[1] / 2.0))
+
+    gaussian = (
+        1.0
+        / (2.0 * np.pi * sigma * sigma)
+        * np.exp(-0.5 * (((i - mu[0]) / sigma) ** 2 + ((j - mu[1]) / sigma) ** 2))
+    )
+
+    gaussian = np.roll(gaussian, (-mu[0], -mu[1]), axis=(0, 1))
+
+    image_fft = np.fft.rfft2(image)
+    gaussian_fft = np.fft.rfft2(gaussian)
+
+    image = np.fft.irfft2(image_fft * gaussian_fft)
+
+    return image
+
+
+def build_heatmap_image(
+    lat_lon_data: np.ndarray, num_activities: int, tile_bounds: TileBounds
+) -> np.ndarray:
+    # fill trackpoints
+    sigma_pixel = 1
+
+    data = np.zeros(tile_bounds.shape)
+
+    xy_data = latlon_to_xy(lat_lon_data[:, 0], lat_lon_data[:, 1], tile_bounds.zoom)
+    xy_data = np.array(xy_data).T
+    xy_data = np.round(
+        (xy_data - [tile_bounds.x_tile_min, tile_bounds.y_tile_min]) * OSM_TILE_SIZE
+    )  # to supertile coordinates
+
+    for j, i in xy_data.astype(int):
+        data[
+            i - sigma_pixel : i + sigma_pixel, j - sigma_pixel : j + sigma_pixel
+        ] += 1.0
+
+    res_pixel = (
+        156543.03
+        * np.cos(np.radians(np.mean(lat_lon_data[:, 0])))
+        / (2.0**tile_bounds.zoom)
+    )  # from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
+
+    # trackpoint max accumulation per pixel = 1/5 (trackpoint/meter) * res_pixel (meter/pixel) * activities
+    # (Strava records trackpoints every 5 meters in average for cycling activites)
+    m = np.round((1.0 / 5.0) * res_pixel * num_activities)
+
+    data[data > m] = m
+
+    # equalize histogram and compute kernel density estimation
+    data_hist, _ = np.histogram(data, bins=int(m + 1))
+
+    data_hist = np.cumsum(data_hist) / data.size  # normalized cumulated histogram
+
+    for i in range(data.shape[0]):
+        for j in range(data.shape[1]):
+            data[i, j] = m * data_hist[int(data[i, j])]  # histogram equalization
+
+    data = gaussian_filter(
+        data, float(sigma_pixel)
+    )  # kernel density estimation with normal kernel
+
+    data = (data - data.min()) / (data.max() - data.min())  # normalize to [0,1]
+
+    # colorize
+    cmap = pl.get_cmap("hot")
+
+    data_color = cmap(data)
+    data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+    return data_color
+
+
+def build_heatmap_tile(lat_lon_data: np.ndarray, tile_bounds: TileBounds) -> np.ndarray:
+    xy_data = latlon_to_xy(lat_lon_data[:, 0], lat_lon_data[:, 1], tile_bounds.zoom)
+    xy_data = np.array(xy_data).T
+
+    xy_data = np.round(
+        (xy_data - [tile_bounds.x_tile_min, tile_bounds.y_tile_min]) * OSM_TILE_SIZE
+    )
+    sigma_pixel = 1
+    data = np.zeros((OSM_TILE_SIZE, OSM_TILE_SIZE))
+    for j, i in xy_data.astype(int):
+        data[
+            i - sigma_pixel : i + sigma_pixel, j - sigma_pixel : j + sigma_pixel
+        ] += 1.0
+
+    np.log(data, where=data > 0, out=data)
+    data /= 6
+    data_max = data.max()
+    if data_max > 2:
+        logger.warning(f"Maximum data in tile: {data_max}")
+    data[data > 1.0] = 1.0
+
+    # colorize
+    cmap = pl.get_cmap("hot")
+
+    data_color = cmap(data)
+    data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+    return data_color

geo_activity_playground-0.11.0/geo_activity_playground/core/test_tiles.py

@@ -0,0 +1,23 @@
+from .tiles import compute_tile
+from .tiles import get_tile_upper_left_lat_lon
+from .tiles import interpolate_missing_tile
+
+
+def test_rheinbach() -> None:
+    lat, lon = 50.6202, 6.9504
+    assert compute_tile(lat, lon, 14) == (8508, 5512)
+
+
+def test_back() -> None:
+    tile_x, tile_y = 8508, 5512
+    zoom = 14
+    lat, lon = get_tile_upper_left_lat_lon(tile_x, tile_y, zoom)
+    print(lat, lon)
+    assert compute_tile(lat, lon, zoom) == (tile_x, tile_y)
+
+
+def test_interpolate() -> None:
+    assert interpolate_missing_tile(1.25, 2.25, 2.5, 1.5) == (1, 1)
+    assert interpolate_missing_tile(2.5, 1.5, 1.25, 2.25) == (1, 1)
+    assert interpolate_missing_tile(2.25, 2.5, 1.75, 1.25) == (2, 1)
+    assert interpolate_missing_tile(1.25, 2.25, 2.25, 2.5) == None

{geo_activity_playground-0.10.0 → geo_activity_playground-0.11.0}/geo_activity_playground/core/tiles.py

@@ -3,6 +3,7 @@ import logging
 import math
 import pathlib
 import time
+from typing import Optional
 
 import numpy as np
 import requests
@@ -20,6 +21,15 @@ def compute_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]:
     return int(x * n), int(y * n)
 
 
+def compute_tile_float(lat: float, lon: float, zoom: int) -> tuple[int, int]:
+    x = np.radians(lon)
+    y = np.arcsinh(np.tan(np.radians(lat)))
+    x = (1 + x / np.pi) / 2
+    y = (1 - y / np.pi) / 2
+    n = 2**zoom
+    return x * n, y * n
+
+
 def get_tile_upper_left_lat_lon(
     tile_x: int, tile_y: int, zoom: int
 ) -> tuple[float, float]:
@@ -79,3 +89,19 @@ def xy_to_latlon(x: float, y: float, zoom: int) -> tuple[float, float]:
     lat_rad = np.arctan(np.sinh(np.pi * (1.0 - 2.0 * y / n)))
     lat_deg = float(np.degrees(lat_rad))
     return lat_deg, lon_deg
+
+
+def interpolate_missing_tile(
+    x1: float, y1: float, x2: float, y2: float
+) -> Optional[tuple[int, int]]:
+    # We are only interested in diagonal tile combinations, therefore we skip adjacent ones.
+    if int(x1) == int(x2) or int(y1) == int(y2):
+        return None
+
+    x_hat = int(max(x1, x2))
+    l = (x_hat - x1) / (x2 - x1)
+    y_hat = int(y1 + l * (y2 - y1))
+    if y_hat == int(y1):
+        return (int(x2), y_hat)
+    else:
+        return (int(x1), y_hat)

geo_activity_playground-0.11.0/geo_activity_playground/explorer/clusters.py

@@ -0,0 +1,260 @@
+import itertools
+import json
+import logging
+import pathlib
+from typing import Iterator
+
+import geojson
+import pandas as pd
+
+from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
+
+
+logger = logging.getLogger(__name__)
+
+
+def adjacent_to(tile: tuple[int, int]) -> Iterator[tuple[int, int]]:
+    x, y = tile
+    yield (x + 1, y)
+    yield (x - 1, y)
+    yield (x, y + 1)
+    yield (x, y - 1)
+
+
+class ExplorerClusterState:
+    def __init__(self, zoom: int) -> None:
+        self.num_neighbors: dict[tuple[int, int], int] = {}
+        self.cluster_tiles: dict[tuple[int, int], list[tuple[int, int]]] = {}
+        self.cluster_evolution = pd.DataFrame()
+        self.start = 0
+
+        self._state_path = pathlib.Path(f"Cache/explorer_cluster_{zoom}_state.json")
+        self._cluster_evolution_path = pathlib.Path(
+            f"Cache/explorer_cluster_{zoom}_evolution.parquet"
+        )
+
+    def load(self) -> None:
+        logger.info("Loading explorer cluster state …")
+        if self._state_path.exists():
+            with open(self._state_path) as f:
+                data = json.load(f)
+            self.num_neighbors = {
+                tuple(map(int, key.split("/"))): value
+                for key, value in data["num_neighbors"].items()
+            }
+            self.cluster_tiles = {
+                tuple(map(int, key.split("/"))): [
+                    tuple(t) for t in data["clusters"][str(value)]
+                ]
+                for key, value in data["memberships"].items()
+            }
+            self.start = data["start"]
+
+        if self._cluster_evolution_path.exists():
+            self.cluster_evolution = pd.read_parquet(self._cluster_evolution_path)
+
+    def save(self) -> None:
+        logger.info("Saving explorer cluster state …")
+        data = {
+            "num_neighbors": {
+                f"{x}/{y}": count for (x, y), count in self.num_neighbors.items()
+            },
+            "memberships": {
+                f"{x}/{y}": id(members)
+                for (x, y), members in self.cluster_tiles.items()
+            },
+            "clusters": {
+                id(members): members for members in self.cluster_tiles.values()
+            },
+            "start": self.start,
+        }
+        with open(self._state_path, "w") as f:
+            json.dump(data, f)
+
+        self.cluster_evolution.to_parquet(self._cluster_evolution_path)
+
+
+def get_explorer_cluster_evolution(zoom: int) -> ExplorerClusterState:
+    tiles = pd.read_parquet(pathlib.Path(f"Cache/first_time_per_tile_{zoom}.parquet"))
+    tiles.sort_values("first_time", inplace=True)
+
+    s = ExplorerClusterState(zoom)
+    s.load()
+
+    logger.info("Compute new explorer cluster state …")
+
+    if len(s.cluster_evolution) > 0:
+        max_cluster_so_far = s.cluster_evolution["max_cluster_size"].iloc[-1]
+    else:
+        max_cluster_so_far = 0
+
+    rows = []
+    for index, row in tiles.iloc[s.start :].iterrows():
+        new_clusters = False
+        # Current tile.
+        tile = (row["tile_x"], row["tile_y"])
+
+        # This tile is new, therefore it doesn't have an entries in the neighbor list yet.
+        s.num_neighbors[tile] = 0
+
+        # Go through the adjacent tile and check whether there are neighbors.
+        for other in adjacent_to(tile):
+            if other in s.num_neighbors:
+                # The other tile is already visited. That means that the current tile has a neighbor.
+                s.num_neighbors[tile] += 1
+                # Alto the other tile has gained a neighbor.
+                s.num_neighbors[other] += 1
+
+        # If the current tile has all neighbors, make it it's own cluster.
+        if s.num_neighbors[tile] == 4:
+            s.cluster_tiles[tile] = [tile]
+
+        # Also make the adjacent tiles their own clusters, if they are full.
+        this_and_neighbors = [tile] + list(adjacent_to(tile))
+        for other in this_and_neighbors:
+            if s.num_neighbors.get(other, 0) == 4:
+                s.cluster_tiles[other] = [other]
+
+        for candidate in this_and_neighbors:
+            if candidate not in s.cluster_tiles:
+                continue
+            # The candidate is a cluster tile. Let's see whether any of the neighbors are also cluster tiles but with a different cluster. Then we need to join them.
+            for other in adjacent_to(candidate):
+                if other not in s.cluster_tiles:
+                    continue
+                # The other tile is also a cluster tile.
+                if s.cluster_tiles[candidate] is s.cluster_tiles[other]:
+                    continue
+                # The two clusters are not the same. We add the other's cluster tile to this tile.
+                s.cluster_tiles[candidate].extend(s.cluster_tiles[other])
+                # Update the other cluster tiles that they now point to the new cluster. This also updates the other tile.
+                for member in s.cluster_tiles[other]:
+                    s.cluster_tiles[member] = s.cluster_tiles[candidate]
+                new_clusters = True
+
+        if new_clusters:
+            max_cluster_size = max(
+                (len(members) for members in s.cluster_tiles.values()),
+                default=0,
+            )
+            if max_cluster_size > max_cluster_so_far:
+                rows.append(
+                    {
+                        "time": row["first_time"],
+                        "max_cluster_size": max_cluster_size,
+                    }
+                )
+                max_cluster_size = max_cluster_so_far
+
+    new_cluster_evolution = pd.DataFrame(rows)
+    s.cluster_evolution = pd.concat([s.cluster_evolution, new_cluster_evolution])
+    s.start = len(tiles)
+    s.save()
+    return s
+
+
+def bounding_box_for_biggest_cluster(
+    clusters: list[list[tuple[int, int]]], zoom: int
+) -> str:
+    biggest_cluster = max(clusters, key=lambda members: len(members))
+    min_x = min(x for x, y in biggest_cluster)
+    max_x = max(x for x, y in biggest_cluster)
+    min_y = min(y for x, y in biggest_cluster)
+    max_y = max(y for x, y in biggest_cluster)
+    lat_max, lon_min = get_tile_upper_left_lat_lon(min_x, min_y, zoom)
+    lat_min, lon_max = get_tile_upper_left_lat_lon(max_x, max_y, zoom)
+    return geojson.dumps(
+        geojson.Feature(
+            geometry=geojson.Polygon(
+                [
+                    [
+                        (lon_min, lat_max),
+                        (lon_max, lat_max),
+                        (lon_max, lat_min),
+                        (lon_min, lat_min),
+                        (lon_min, lat_max),
+                    ]
+                ]
+            ),
+        )
+    )
+
+
+class SquareHistoryState:
+    def __init__(self, zoom: int) -> None:
+        self._state_path = pathlib.Path(f"Cache/square_history_{zoom}_state.json")
+        self._square_history_path = pathlib.Path(f"Cache/square_history_{zoom}.parquet")
+
+        self.max_square_size = 0
+        self.start = 0
+        self.visited_tiles = set()
+        self.square_history = pd.DataFrame()
+
+    def load(self) -> None:
+        logger.info("Load explorer square state …")
+        if self._state_path.exists():
+            with open(self._state_path) as f:
+                data = json.load(f)
+            self.visited_tiles = set((x, y) for x, y in data["visited_tiles"])
+            self.max_square_size = data["max_square_size"]
+            self.start = data["start"]
+
+        if self._square_history_path.exists():
+            self.square_history = pd.read_parquet(self._square_history_path)
+
+    def save(self) -> None:
+        logger.info("Save explorer square state …")
+        data = {
+            "max_square_size": self.max_square_size,
+            "visited_tiles": list(self.visited_tiles),
+            "start": self.start,
+        }
+        with open(self._state_path, "w") as f:
+            json.dump(data, f)
+
+        self.square_history.to_parquet(self._square_history_path)
+
+
+def get_square_history(zoom: int) -> SquareHistoryState:
+    tiles = pd.read_parquet(f"Cache/first_time_per_tile_{zoom}.parquet")
+    tiles.sort_values("first_time", inplace=True)
+    s = SquareHistoryState(zoom)
+    s.load()
+    logger.info("Compute new explorer square state …")
+    rows = []
+    for index, row in tiles.iloc[s.start :].iterrows():
+        tile = (row["tile_x"], row["tile_y"])
+        x, y = tile
+        s.visited_tiles.add(tile)
+        for square_size in itertools.count(s.max_square_size + 1):
+            this_tile_size_viable = False
+            for x_offset in range(square_size):
+                for y_offset in range(square_size):
+                    this_offset_viable = True
+                    for xx in range(square_size):
+                        for yy in range(square_size):
+                            if (
+                                x + xx - x_offset,
+                                y + yy - y_offset,
+                            ) not in s.visited_tiles:
+                                this_offset_viable = False
+                                break
+                        if not this_offset_viable:
+                            break
+                    if this_offset_viable:
+                        s.max_square_size = square_size
+                        rows.append(
+                            {"time": row["first_time"], "max_square_size": square_size}
+                        )
+                        this_tile_size_viable = True
+                        break
+                if this_tile_size_viable:
+                    break
+            if not this_tile_size_viable:
+                break
+
+    new_square_history = pd.DataFrame(rows)
+    s.square_history = pd.concat([s.square_history, new_square_history])
+    s.start = len(tiles)
+    s.save()
+    return s