huff 1.0.0__py3-none-any.whl

huff/gistools.py

@@ -0,0 +1,49 @@
+#-----------------------------------------------------------------------
+# Name:        gistools (huff package)
+# Purpose:     GIS tools
+# Author:      Thomas Wieland 
+#              ORCID: 0000-0001-5168-9846
+#              mail: geowieland@googlemail.com              
+# Version:     1.0.0
+# Last update: 2025-04-25 18:16
+# Copyright (c) 2025 Thomas Wieland
+#-----------------------------------------------------------------------
+
+
+import geopandas as gp 
+
+
+def overlay_difference(
+    polygon_gdf: gp.GeoDataFrame, 
+    sort_col: str = None,
+    ):
+
+    if sort_col is not None:
+        polygon_gdf = polygon_gdf.sort_values(by=sort_col).reset_index(drop=True)
+    else:
+        polygon_gdf = polygon_gdf.reset_index(drop=True)
+
+    new_geometries = []
+    new_data = []
+
+    for i in range(len(polygon_gdf) - 1, 0, -1):
+        current_polygon = polygon_gdf.iloc[i].geometry
+        previous_polygon = polygon_gdf.iloc[i - 1].geometry
+        difference_polygon = current_polygon.difference(previous_polygon)
+
+        if difference_polygon.is_empty or not difference_polygon.is_valid:
+            continue
+
+        new_geometries.append(difference_polygon)
+        new_data.append(polygon_gdf.iloc[i].drop("geometry"))
+
+    inner_most_polygon = polygon_gdf.iloc[0].geometry
+    if inner_most_polygon.is_valid:
+        new_geometries.append(inner_most_polygon)
+        new_data.append(polygon_gdf.iloc[0].drop("geometry"))
+
+    polygon_gdf_difference = gp.GeoDataFrame(
+        new_data, geometry=new_geometries, crs=polygon_gdf.crs
+    )
+
+    return polygon_gdf_difference

huff/models.py

@@ -0,0 +1,585 @@
+#-----------------------------------------------------------------------
+# Name:        models (huff package)
+# Purpose:     Huff Model classes and functions
+# Author:      Thomas Wieland 
+#              ORCID: 0000-0001-5168-9846
+#              mail: geowieland@googlemail.com              
+# Version:     1.0.0
+# Last update: 2025-04-25 18:13
+# Copyright (c) 2025 Thomas Wieland
+#-----------------------------------------------------------------------
+
+
+import pandas as pd
+import geopandas as gp
+import numpy as np
+from .ors import matrix
+
+
+class CustomerOrigins:
+
+    def __init__(
+        self,
+        geodata_gpd, 
+        geodata_gpd_original, 
+        metadata
+        ):
+
+        self.geodata_gpd = geodata_gpd
+        self.geodata_gpd_original = geodata_gpd_original
+        self.metadata = metadata
+
+    def get_geodata_gpd(self):
+
+        return self.geodata_gpd
+
+    def get_geodata_gpd_original(self):
+
+        return self.geodata_gpd_original
+
+    def get_metadata(self):
+        
+        return self.metadata
+
+    def summary(self):
+
+        metadata = self.metadata
+
+        print("Huff Model Customer Origins")
+        print("No. locations              " + str(metadata["no_points"]))
+        
+        if metadata["marketsize_col"] is None:
+            print("Market size column         not defined")
+        else:
+            print("Market size column         " + metadata["marketsize_col"])
+        
+        if metadata["weighting"][0]["func"] is None and metadata["weighting"][0]["param"] is None:
+            print("Transport cost weighting   not defined")
+        else:
+            print("Transport cost weighting   " + metadata["weighting"][0]["func"] + " with lambda = " + str(metadata["weighting"][0]["param"]))
+        
+        print("Unique ID column           " + metadata["unique_id"])
+        print("Input CRS                  " + str(metadata["crs_input"]))
+
+        return metadata
+    
+    def define_marketsize(
+        self,
+        marketsize_col
+        ):
+
+        geodata_gpd_original = self.geodata_gpd_original
+        metadata = self.metadata
+
+        if marketsize_col not in geodata_gpd_original.columns:
+            raise KeyError ("Column " + marketsize_col + " not in data")
+        else:
+            metadata["marketsize_col"] = marketsize_col
+
+        self.metadata = metadata
+
+        return self
+
+    def define_transportcosts_weighting(
+        self,
+        func = "power",
+        param_lambda = -2
+        ):
+
+        metadata = self.metadata
+
+        metadata["weighting"][0]["func"] = func
+        metadata["weighting"][0]["param"] = param_lambda
+
+        self.metadata = metadata
+
+        return self
+
+class SupplyLocations:
+
+    def __init__(
+        self,
+        geodata_gpd, 
+        geodata_gpd_original, 
+        metadata
+        ):
+
+        self.geodata_gpd = geodata_gpd
+        self.geodata_gpd_original = geodata_gpd_original
+        self.metadata = metadata
+
+    def get_geodata_gpd(self):
+        return self.geodata_gpd
+
+    def get_geodata_gpd_original(self):
+        return self.geodata_gpd_original
+
+    def get_metadata(self):
+        return self.metadata
+
+    def summary(self):
+
+        metadata = self.metadata
+
+        print("Huff Model Supply Locations")
+        print("No. locations         " + str(metadata["no_points"]))
+
+        if metadata["attraction_col"][0] is None or metadata["attraction_col"] == []:
+            print("Attraction column(s)  not defined")
+        else:
+            print("Attraction column(s)  " + ",".join(metadata["attraction_col"]))
+        
+        if metadata["weighting"][0]["func"] is None and metadata["weighting"][0]["param"] is None:
+            print("Attraction weighting  not defined")
+        else:
+            print("Attraction weighting  " + metadata["weighting"][0]["func"] + " with gamma = " + str(metadata["weighting"][0]["param"]))
+        
+        print("Unique ID column      " + metadata["unique_id"])
+        print("Input CRS             " + str(metadata["crs_input"]))
+
+        return metadata
+
+    def define_attraction(
+        self,
+        attraction_col
+        ):
+
+        geodata_gpd_original = self.geodata_gpd_original
+        metadata = self.metadata
+
+        if attraction_col not in geodata_gpd_original.columns:
+            raise KeyError ("Column " + attraction_col + " not in data")
+        else:
+            metadata["attraction_col"][0] = attraction_col
+
+        self.metadata = metadata
+
+        return self
+    
+    def define_attraction_weighting(
+        self,
+        func = "power",
+        param_gamma = 1
+        ):
+
+        metadata = self.metadata
+
+        if metadata["attraction_col"] is None:
+            raise ValueError ("Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
+        
+        metadata["weighting"][0]["func"] = func
+        metadata["weighting"][0]["param"] = param_gamma
+        self.metadata = metadata
+
+        return self
+
+    def add_var(
+        self,
+        var: str = None,
+        func: str = None,
+        param: float = None
+        ):
+
+        metadata = self.metadata
+
+        if metadata["attraction_col"] is None:
+            raise ValueError ("Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
+
+        no_attraction_vars = len(metadata["attraction_col"])
+        new_key = no_attraction_vars
+
+        metadata["attraction_col"] = metadata["attraction_col"] + [var] 
+
+        metadata["weighting"][new_key] = {
+            "func": func,
+            "param": param
+            }
+
+        self.metadata = metadata
+
+        return self
+
+class InteractionMatrix:
+
+    def __init__(
+        self, 
+        interaction_matrix_df,
+        market_areas_df,
+        customer_origins,
+        supply_locations
+        ):
+
+        self.interaction_matrix_df = interaction_matrix_df
+        self.market_areas_df = market_areas_df
+        self.customer_origins = customer_origins
+        self.supply_locations = supply_locations
+    
+    def get_interaction_matrix_df(self):
+        return self.interaction_matrix_df
+    
+    def get_market_areas_df(self):
+        return self.market_areas_df
+
+    def get_customer_origins(self):
+        return self.customer_origins
+
+    def get_supply_locations(self):
+        return self.supply_locations
+    
+    def summary(self):
+
+        customer_origins_metadata = self.get_customer_origins().get_metadata()
+        supply_locations_metadata = self.get_supply_locations().get_metadata()
+
+        print("Huff Model")
+        print("----------------------------------")
+        print("Supply locations   " + str(supply_locations_metadata["no_points"]))
+        if supply_locations_metadata["attraction_col"][0] is None:
+            print("Attraction column  not defined")
+        else:
+            print("Attraction column  " + supply_locations_metadata["attraction_col"][0])
+        print("Customer origins   " + str(customer_origins_metadata["no_points"]))
+        if customer_origins_metadata["marketsize_col"] is None:
+            print("Market size column not defined")
+        else:
+            print("Market size column " + customer_origins_metadata["marketsize_col"])
+        print("----------------------------------")
+        print("Weights")
+        if supply_locations_metadata["weighting"][0]["func"] is None and supply_locations_metadata["weighting"][0]["param"] is None:
+            print("Gamma              not defined")
+        else:
+            print("Gamma              " + str(supply_locations_metadata["weighting"][0]["param"]) + " (" + supply_locations_metadata["weighting"][0]["func"] + ")")
+        if customer_origins_metadata["weighting"][0]["func"] is None and customer_origins_metadata["weighting"][0]["param"] is None:
+            print("Lambda             not defined")
+        else:
+            print("Lambda            " + str(customer_origins_metadata["weighting"][0]["param"]) + " (" + customer_origins_metadata["weighting"][0]["func"] + ")")     
+        print("----------------------------------")
+
+    def transport_costs(
+        self,
+        range_type: str = "time",
+        time_unit: str = "minutes",
+        ors_auth: str = None,
+        save_output: bool = False,
+        output_filepath: str = "transport_costs_matrix.csv"
+        ):
+        
+        interaction_matrix_df = self.get_interaction_matrix_df()
+
+        customer_origins = self.get_customer_origins()
+        customer_origins_geodata_gpd = customer_origins.get_geodata_gpd()
+        customer_origins_metadata = customer_origins.get_metadata()
+        customer_origins_uniqueid = customer_origins_metadata["unique_id"]
+        customer_origins_coords = [[point.x, point.y] for point in customer_origins_geodata_gpd.geometry]
+        customer_origins_ids = customer_origins_geodata_gpd[customer_origins_uniqueid].tolist()
+
+        supply_locations = self.get_supply_locations()
+        supply_locations_geodata_gpd = supply_locations.get_geodata_gpd()
+        supply_locations_metadata = supply_locations.get_metadata()
+        supply_locations_uniqueid = supply_locations_metadata["unique_id"]
+        supply_locations_coords = [[point.x, point.y] for point in supply_locations_geodata_gpd.geometry]
+        supply_locations_ids = supply_locations_geodata_gpd[supply_locations_uniqueid].tolist()
+   
+        locations_coords = customer_origins_coords + supply_locations_coords        
+        
+        customer_origins_index = list(range(len(customer_origins_coords)))
+        locations_coords_index = list(range(len(customer_origins_index), len(locations_coords)))
+    
+        time_distance_matrix = matrix(
+            auth = ors_auth,
+            locations = locations_coords,
+            save_output = save_output,
+            output_filepath = output_filepath, 
+            sources = customer_origins_index,
+            destinations = locations_coords_index,
+            range_type = range_type
+            )
+        
+        transport_costs_matrix = time_distance_matrix.get_matrix()
+        transport_costs_matrix_config = time_distance_matrix.get_config()
+        range_type = transport_costs_matrix_config["range_type"]
+
+        transport_costs_matrix["source"] = transport_costs_matrix["source"].astype(int)
+        transport_costs_matrix["source"] = transport_costs_matrix["source"].map(
+            dict(enumerate(customer_origins_ids))
+            )
+        
+        transport_costs_matrix["destination"] = transport_costs_matrix["destination"].astype(int)
+        transport_costs_matrix["destination"] = transport_costs_matrix["destination"].map(
+            dict(enumerate(supply_locations_ids))
+            )
+        
+        transport_costs_matrix["source_destination"] = transport_costs_matrix["source"].astype(str)+"_"+transport_costs_matrix["destination"].astype(str)
+        transport_costs_matrix = transport_costs_matrix[["source_destination", range_type]]
+
+        interaction_matrix_df = interaction_matrix_df.merge(
+            transport_costs_matrix,
+            left_on="ij",
+            right_on="source_destination"
+            )
+        
+        interaction_matrix_df["t_ij"] = interaction_matrix_df[range_type]
+        if time_unit == "minutes":
+            interaction_matrix_df["t_ij"] = interaction_matrix_df["t_ij"]/60
+        if time_unit == "hours":
+            interaction_matrix_df["t_ij"] = interaction_matrix_df["t_ij"]/60/60
+
+        interaction_matrix_df = interaction_matrix_df.drop(columns=["source_destination", range_type])
+
+        self.interaction_matrix_df = interaction_matrix_df
+
+        return self
+    
+    def utility(self):
+        
+        interaction_matrix_df = self.interaction_matrix_df
+
+        if interaction_matrix_df["t_ij"].isna().all():
+            raise ValueError ("Transport cost variable is not defined")
+        if interaction_matrix_df["A_j"].isna().all():
+            raise ValueError ("Attraction variable is not defined")
+
+        customer_origins = self.customer_origins
+        customer_origins_metadata = customer_origins.get_metadata()
+        tc_weighting = customer_origins_metadata["weighting"][0]
+        if tc_weighting["func"] == "power":
+            interaction_matrix_df["t_ij_weighted"] = interaction_matrix_df["t_ij"] ** tc_weighting["param"]
+        elif tc_weighting["func"] == "exponential":
+            interaction_matrix_df["t_ij_weighted"] = np.exp(tc_weighting["param"] * interaction_matrix_df['t_ij'])
+        else:
+            raise ValueError ("Transport costs weighting is not defined.")
+                           
+        supply_locations = self.supply_locations
+        supply_locations_metadata = supply_locations.get_metadata()
+        attraction_weighting = supply_locations_metadata["weighting"][0]
+        if attraction_weighting["func"] == "power":
+            interaction_matrix_df["A_j_weighted"] = interaction_matrix_df["A_j"] ** attraction_weighting["param"]
+        elif tc_weighting["func"] == "exponential":
+            interaction_matrix_df["A_j_weighted"] = np.exp(attraction_weighting["param"] * interaction_matrix_df['A_j'])
+        else:
+            raise ValueError ("Attraction weighting is not defined.")
+        
+        interaction_matrix_df["U_ij"] = interaction_matrix_df["A_j_weighted"]/interaction_matrix_df["t_ij_weighted"]
+        
+        interaction_matrix_df = interaction_matrix_df.drop(columns=['A_j_weighted', 't_ij_weighted'])
+
+        self.interaction_matrix_df = interaction_matrix_df
+
+        return self
+    
+    def probabilities (self):
+
+        interaction_matrix_df = self.interaction_matrix_df
+
+        if interaction_matrix_df["U_ij"].isna().all():
+            self.utility()
+            interaction_matrix_df = self.interaction_matrix_df
+
+        utility_i = pd.DataFrame(interaction_matrix_df.groupby("i")["U_ij"].sum())
+        utility_i = utility_i.rename(columns = {"U_ij": "U_i"})
+
+        interaction_matrix_df = interaction_matrix_df.merge(
+            utility_i,
+            left_on="i",
+            right_on="i",
+            how="inner"
+            )
+
+        interaction_matrix_df["p_ij"] = (interaction_matrix_df["U_ij"]) / (interaction_matrix_df["U_i"])
+
+        interaction_matrix_df = interaction_matrix_df.drop(columns=["U_i"])
+
+        self.interaction_matrix_df = interaction_matrix_df
+
+        return self
+        
+    def flows (self):
+
+        interaction_matrix_df = self.interaction_matrix_df
+
+        if interaction_matrix_df["C_i"].isna().all():
+            raise ValueError ("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
+
+        if interaction_matrix_df["p_ij"].isna().all():
+            self.probabilities()
+            interaction_matrix_df = self.interaction_matrix_df
+
+        interaction_matrix_df["E_ij"] = interaction_matrix_df["p_ij"] * interaction_matrix_df["C_i"]
+
+        self.interaction_matrix_df = interaction_matrix_df
+
+        return self
+
+    def marketareas (self):
+
+        interaction_matrix_df = self.interaction_matrix_df
+
+        market_areas_df = pd.DataFrame(interaction_matrix_df.groupby("j")["E_ij"].sum())
+        market_areas_df = market_areas_df.reset_index(drop=False)
+        market_areas_df = market_areas_df.rename(columns={"E_ij": "T_j"})
+
+        print(market_areas_df)
+
+        self.market_areas_df = market_areas_df
+
+        return self
+
+def load_geodata (
+    file, 
+    location_type: str, 
+    unique_id: str,
+    x_col: str = None, 
+    y_col: str = None,
+    data_type = "shp", 
+    csv_sep = ";", 
+    csv_decimal = ",", 
+    csv_encoding="unicode_escape", 
+    crs_input = "EPSG:4326"    
+    ):
+
+    if location_type is None or (location_type != "origins" and location_type != "destinations"):
+        raise ValueError ("location_type must be either 'loc' or 'dest'")
+    
+    if data_type not in ["shp", "csv", "xlsx"]:
+        raise ValueError ("data_type must be 'shp', 'csv' or 'xlsx'")
+
+    if data_type == "shp":
+        geodata_gpd_original = gp.read_file(file)
+        crs_input = geodata_gpd_original.crs
+
+    if data_type == "csv" or data_type == "xlsx":
+        if x_col is None:
+            raise ValueError ("Missing value for X coordinate column")
+        if y_col is None:
+            raise ValueError ("Missing value for Y coordinate column")
+
+    if data_type == "csv":
+        geodata_tab = pd.read_csv(
+            file, 
+            sep = csv_sep, 
+            decimal = csv_decimal, 
+            encoding = csv_encoding
+            )
+    
+    if data_type == "xlsx":
+        geodata_tab = pd.read_excel(file)
+
+    if data_type == "csv" or data_type == "xlsx":
+        geodata_gpd_original = gp.GeoDataFrame(
+            geodata_tab, 
+            geometry = gp.points_from_xy(
+                geodata_tab[x_col], 
+                geodata_tab[y_col]
+                ), 
+            crs = crs_input
+            )
+
+    crs_output = "EPSG:4326"
+    geodata_gpd = geodata_gpd_original.to_crs(crs_output)
+    geodata_gpd = geodata_gpd[[unique_id, "geometry"]]
+
+    metadata = {
+        "location_type": location_type,
+        "unique_id": unique_id,
+        "attraction_col": [None],
+        "marketsize_col": None,
+        "weighting": {
+            0: {
+                "func": None, 
+                "param": None
+                }
+            },
+        "crs_input": crs_input,
+        "crs_output": crs_output,
+        "no_points": len(geodata_gpd)
+        }    
+    
+    if location_type == "origins":
+        geodata_object = CustomerOrigins(
+            geodata_gpd, 
+            geodata_gpd_original, 
+            metadata
+            )        
+    elif location_type == "destinations":
+        geodata_object = SupplyLocations(
+            geodata_gpd, 
+            geodata_gpd_original, 
+            metadata
+            )
+
+    return geodata_object
+    
+def create_interaction_matrix(
+    customer_origins,
+    supply_locations    
+    ):
+
+    if not isinstance(customer_origins, CustomerOrigins):
+        raise ValueError ("customer_origins must be of class CustomerOrigins")
+    if not isinstance(supply_locations, SupplyLocations):
+        raise ValueError ("supply_locations must be of class supply_locations")
+
+    customer_origins_metadata = customer_origins.get_metadata()
+    if customer_origins_metadata["marketsize_col"] is None:
+        raise ValueError("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
+    
+    supply_locations_metadata = supply_locations.get_metadata()
+    if supply_locations_metadata["attraction_col"][0] is None:
+        raise ValueError("Attraction column in supply locations not defined. Use SupplyLocations.define_attraction()")
+
+    customer_origins_unique_id = customer_origins_metadata["unique_id"]
+    customer_origins_marketsize = customer_origins_metadata["marketsize_col"]
+
+    customer_origins_geodata_gpd = pd.DataFrame(customer_origins.get_geodata_gpd())
+    customer_origins_geodata_gpd_original = pd.DataFrame(customer_origins.get_geodata_gpd_original())
+    customer_origins_data = pd.merge(
+        customer_origins_geodata_gpd,
+        customer_origins_geodata_gpd_original[[customer_origins_unique_id, customer_origins_marketsize]],
+        left_on = customer_origins_unique_id,
+        right_on = customer_origins_unique_id 
+        )
+    customer_origins_data = customer_origins_data.rename(columns = {
+        customer_origins_unique_id: "i",
+        customer_origins_marketsize: "C_i",
+        "geometry": "i_coords"
+        }
+        )
+
+    supply_locations_unique_id = supply_locations_metadata["unique_id"]
+    supply_locations_attraction = supply_locations_metadata["attraction_col"][0]
+
+    supply_locations_geodata_gpd = pd.DataFrame(supply_locations.get_geodata_gpd())
+    supply_locations_geodata_gpd_original = pd.DataFrame(supply_locations.get_geodata_gpd_original())
+    supply_locations_data = pd.merge(
+        supply_locations_geodata_gpd,
+        supply_locations_geodata_gpd_original[[supply_locations_unique_id, supply_locations_attraction]],
+        left_on = supply_locations_unique_id,
+        right_on = supply_locations_unique_id 
+        )
+    supply_locations_data = supply_locations_data.rename(columns = {
+        supply_locations_unique_id: "j",
+        supply_locations_attraction: "A_j",
+        "geometry": "j_coords"
+        }
+        )
+
+    interaction_matrix_df = customer_origins_data.merge(
+        supply_locations_data, 
+        how = "cross"
+        )
+    interaction_matrix_df["ij"] = interaction_matrix_df["i"].astype(str)+"_"+interaction_matrix_df["j"].astype(str)
+    interaction_matrix_df["t_ij"] = None
+    interaction_matrix_df["U_ij"] = None
+    interaction_matrix_df["p_ij"] = None
+    interaction_matrix_df["E_ij"] = None
+
+    market_areas_df = None
+
+    interaction_matrix = InteractionMatrix(
+        interaction_matrix_df,
+        market_areas_df,
+        customer_origins,
+        supply_locations
+        )
+         
+    return interaction_matrix

huff/ors.py

@@ -0,0 +1,334 @@
+#-----------------------------------------------------------------------
+# Name:        ors (huff package)
+# Purpose:     OpenRouteService client
+# Author:      Thomas Wieland 
+#              ORCID: 0000-0001-5168-9846
+#              mail: geowieland@googlemail.com              
+# Version:     1.0.0
+# Last update: 2025-04-25 18:14
+# Copyright (c) 2025 Thomas Wieland
+#-----------------------------------------------------------------------
+
+
+import pandas as pd
+import requests
+import geopandas as gp
+from shapely.geometry import Point, MultiPoint, shape, Polygon
+from shapely.ops import unary_union
+
+
+class Isochrone:
+
+    def __init__(
+        self, 
+        isochrones_gdf, 
+        metadata,
+        status_code,
+        save_config
+        ):
+
+        self.isochrones_gdf = isochrones_gdf
+        self.metadata = metadata
+        self.status_code = status_code
+        self.save_config = save_config
+
+    def summary(self):
+
+        metadata = self.metadata
+        status_code = self.status_code
+
+        range_str = [str(range) for range in metadata["query"]["range"]]
+        profile = metadata["query"]["profile"]
+        range_type = metadata["query"]["range_type"]
+        no_locations = len(metadata["query"]["locations"]) #[str(seg) for seg in metadata["query"]["locations"]]
+
+        print("Locations:   " + str(no_locations))
+        print("Segments:    " + ", ".join(range_str))
+        print("Range type:  " + range_type)
+        print("Profile:     " + profile)
+        print("Status code: " + str(status_code))
+
+
+class TimeDistanceMatrix:
+
+    def __init__(
+        self, 
+        matrix_df, 
+        metadata,
+        status_code,
+        save_config
+        ):
+
+        self.matrix_df = matrix_df
+        self.metadata = metadata
+        self.status_code = status_code
+        self.save_config = save_config
+
+    def get_matrix(self):
+
+        return self.matrix_df
+    
+    def get_metadata(self):
+
+        return self.metadata
+    
+    def get_config(self):
+
+        return self.save_config
+    
+    def summary(self):
+
+        metadata = self.metadata
+        status_code = self.status_code
+
+        pass # TODO ??
+
+
+def isochrone(
+    auth: str,
+    locations: list,
+    id: list = [],
+    segments: list = [900, 600, 300],
+    range_type: str = "time",
+    intersections: str = "true",
+    profile: str = "driving-car",
+    save_output: bool = True,
+    output_filepath: str = "isochrones.shp",
+    output_crs: str = "EPSG:2056",
+    verbose: bool = True
+    ):
+
+    ors_url = "https://api.openrouteservice.org/v2/isochrones/" + profile
+
+    headers = {
+        "Content-Type": "application/json; charset=utf-8",
+        "Accept": "application/json, application/geo+json, application/gpx+xml, img/png; charset=utf-8",
+        "Authorization": auth
+    }
+
+    body = {
+        "locations": locations,
+        "range": segments,
+        "intersections": intersections,
+        "range_type": range_type
+    }
+
+    try:
+
+        response = requests.post(
+            ors_url, 
+            headers=headers, 
+            json=body
+            )
+        
+    except:
+
+        if verbose is True:
+            print ("Unknown error while accessing ORS server")
+        
+        status_code = 99999
+        isochrones_gdf = None 
+        metadata = None
+
+    status_code = response.status_code
+
+    if status_code == 200:
+
+        if verbose is True:
+            print ("Accessing ORS server successful")
+
+        response_json = response.json()
+        
+        metadata = response_json["metadata"]
+        
+        features = response_json["features"]
+        geometries = [shape(feature["geometry"]) for feature in features]
+
+        isochrones_gdf = gp.GeoDataFrame(
+            features, 
+            geometry=geometries, 
+            crs="EPSG:4326"
+            )
+
+        isochrones_gdf["segment"] = 0
+        isochrones_gdf_properties_dict = dict(isochrones_gdf["properties"])
+
+        for i in range(len(isochrones_gdf_properties_dict)):
+            isochrones_gdf.iloc[i,3] = isochrones_gdf_properties_dict[i]["value"]
+
+        isochrones_gdf = isochrones_gdf.drop(columns=["properties"])
+        isochrones_gdf = isochrones_gdf.to_crs(output_crs)
+
+        if save_output:
+            isochrones_gdf.to_file(output_filepath)
+            print ("Saved as", output_filepath)
+
+    else:
+
+        if verbose is True:
+            print ("Error while accessing ORS server. Status Code: " + str(status_code))
+
+        isochrones_gdf = None
+        metadata = None
+
+    save_config = {
+        "range_type": range_type,
+        "save_output": save_output,
+        "output_filepath" : output_filepath,
+        "output_crs": output_crs
+        }
+    
+    isochrone_output = Isochrone(
+        isochrones_gdf, 
+        metadata,
+        status_code,
+        save_config
+        )
+    
+    return isochrone_output
+
+def matrix(
+    auth,
+    locations: list,
+    sources: list = [],
+    destinations: list = [],
+    id: str = None,
+    range_type = "time",
+    metrics: list = [],
+    resolve_locations: bool = False,    
+    units: str = "mi",
+    save_output = False,
+    output_filepath = "matrix.csv",
+    csv_sep = ";",
+    csv_decimal = ",",
+    csv_encoding = None,
+    verbose = True
+    ):
+
+    ors_url = "https://api.openrouteservice.org/v2/matrix/driving-car"
+
+    headers = {
+        "Content-Type": "application/json; charset=utf-8",
+        "Accept": "application/json, application/geo+json, application/gpx+xml, img/png; charset=utf-8",
+        "Authorization": auth
+    }
+
+    body = {
+        "locations": locations,
+        "resolve_locations": resolve_locations
+    }
+    if id is not None:
+        body["id"] = id
+    if metrics != []:
+        body["metrics"] = metrics
+    if sources != []:
+        body["sources"] = sources
+    if destinations != []:
+        body["destinations"] = destinations
+    if units is not None:
+        body["units"] = units
+
+    try:
+
+        response = requests.post(
+            ors_url, 
+            headers=headers, 
+            json=body
+            )
+        
+    except:
+        
+        if verbose is True:
+            print ("Unknown error while accessing ORS server")
+        
+        status_code = 99999
+        matrix_df = None
+        metadata = None
+        
+    status_code = response.status_code
+
+    if status_code == 200:
+
+        if verbose is True:
+            print ("Accessing ORS server successful")
+
+        response_json = response.json()
+
+        metadata = response_json["metadata"]
+
+        matrix_df = pd.DataFrame(
+            columns=[
+                "source",
+                "source_lat",
+                "source_lon",
+                "source_snapped_distance",
+                "destination",
+                "destination_lat",
+                "destination_lon", 
+                "destination_snapped_distance",
+                "source_destination", 
+                range_type
+                ])
+
+        for i, value in enumerate(response_json["durations"]):
+
+            source_lat = response_json["sources"][i]["location"][1]
+            source_lon = response_json["sources"][i]["location"][0]
+            source_snapped_distance = response_json["sources"][i]["snapped_distance"]
+            
+            for j, entry in enumerate(value):
+
+                destination_lat = response_json["destinations"][j]["location"][1]
+                destination_lon = response_json["destinations"][j]["location"][0]
+                destination_snapped_distance = response_json["destinations"][j]["snapped_distance"]
+
+                matrix_row = pd.Series(
+                    {
+                        "source": str(i),
+                        "source_lat": source_lat,
+                        "source_lon": source_lon,
+                        "source_snapped_distance": source_snapped_distance,
+                        "destination": str(j),
+                        "destination_lat": destination_lat,
+                        "destination_lon": destination_lon,
+                        "destination_snapped_distance": destination_snapped_distance,
+                        "source_destination": str(i)+"_"+str(j), 
+                        range_type: entry
+                        }
+                        )
+
+                matrix_df = pd.concat([
+                    matrix_df, 
+                    pd.DataFrame([matrix_row])])
+
+        if save_output:
+            matrix_df.to_csv(
+                output_filepath, 
+                decimal = csv_decimal, 
+                sep = csv_sep, 
+                encoding = csv_encoding
+                )
+            print ("Saved as", output_filepath)
+
+    else:
+
+        if verbose is True:
+            print ("Error in accessing ORS server. Status Code: " + str(status_code))
+
+        matrix_df = None
+        metadata = None
+
+    save_config = {
+        "range_type": range_type,
+        "save_output": save_output,
+        "output_filepath": output_filepath
+    }
+
+    matrix_output = TimeDistanceMatrix(
+        matrix_df, 
+        metadata,
+        status_code,
+        save_config
+        )
+    
+    return matrix_output

huff/tests/data/Haslach.cpg

@@ -0,0 +1 @@
+UTF-8

huff/tests/data/Haslach.prj

@@ -0,0 +1 @@
+PROJCS["DHDN_3_Degree_Gauss_Zone_3",GEOGCS["GCS_Deutsches_Hauptdreiecksnetz",DATUM["D_Deutsches_Hauptdreiecksnetz",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Gauss_Kruger"],PARAMETER["False_Easting",3500000.0],PARAMETER["False_Northing",0.0],PARAMETER["Central_Meridian",9.0],PARAMETER["Scale_Factor",1.0],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]

huff/tests/data/Haslach.qmd

@@ -0,0 +1,43 @@
+<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'>
+<qgis version="3.28.3-Firenze">
+  <identifier></identifier>
+  <parentidentifier></parentidentifier>
+  <language></language>
+  <type>dataset</type>
+  <title></title>
+  <abstract></abstract>
+  <contact>
+    <name></name>
+    <organization></organization>
+    <position></position>
+    <voice></voice>
+    <fax></fax>
+    <email></email>
+    <role></role>
+  </contact>
+  <links/>
+  <fees></fees>
+  <encoding></encoding>
+  <crs>
+    <spatialrefsys nativeFormat="Wkt">
+      <wkt>PROJCRS["DHDN / 3-degree Gauss-Kruger zone 3",BASEGEOGCRS["DHDN",DATUM["Deutsches Hauptdreiecksnetz",ELLIPSOID["Bessel 1841",6377397.155,299.1528128,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4314]],CONVERSION["3-degree Gauss-Kruger zone 3",METHOD["Transverse Mercator",ID["EPSG",9807]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",9,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["Scale factor at natural origin",1,SCALEUNIT["unity",1],ID["EPSG",8805]],PARAMETER["False easting",3500000,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["northing (X)",north,ORDER[1],LENGTHUNIT["metre",1]],AXIS["easting (Y)",east,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Cadastre, engineering survey, topographic mapping."],AREA["Germany - former West Germany onshore between 7�30'E and 10�30'E - states of Baden-Wurtemberg, Bayern, Bremen, Hamberg, Hessen, Niedersachsen, Nordrhein-Westfalen, Rhineland-Pfalz, Schleswig-Holstein."],BBOX[47.27,7.5,55.09,10.51]],ID["EPSG",31467]]</wkt>
+      <proj4>+proj=tmerc +lat_0=0 +lon_0=9 +k=1 +x_0=3500000 +y_0=0 +ellps=bessel +towgs84=598.1,73.7,418.2,0.202,0.045,-2.455,6.7 +units=m +no_defs</proj4>
+      <srsid>2647</srsid>
+      <srid>31467</srid>
+      <authid>EPSG:31467</authid>
+      <description>DHDN / 3-degree Gauss-Kruger zone 3</description>
+      <projectionacronym>tmerc</projectionacronym>
+      <ellipsoidacronym>EPSG:7004</ellipsoidacronym>
+      <geographicflag>false</geographicflag>
+    </spatialrefsys>
+  </crs>
+  <extent>
+    <spatial maxy="0" dimensions="2" maxx="0" maxz="0" crs="EPSG:31467" miny="0" minz="0" minx="0"/>
+    <temporal>
+      <period>
+        <start></start>
+        <end></end>
+      </period>
+    </temporal>
+  </extent>
+</qgis>

huff/tests/data/Haslach_supermarkets.cpg

@@ -0,0 +1 @@
+UTF-8

huff/tests/data/Haslach_supermarkets.prj

@@ -0,0 +1 @@
+PROJCS["DHDN_3_Degree_Gauss_Zone_3",GEOGCS["GCS_Deutsches_Hauptdreiecksnetz",DATUM["D_Deutsches_Hauptdreiecksnetz",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Gauss_Kruger"],PARAMETER["False_Easting",3500000.0],PARAMETER["False_Northing",0.0],PARAMETER["Central_Meridian",9.0],PARAMETER["Scale_Factor",1.0],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]

huff/tests/data/Haslach_supermarkets.qmd

@@ -0,0 +1,43 @@
+<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'>
+<qgis version="3.28.3-Firenze">
+  <identifier></identifier>
+  <parentidentifier></parentidentifier>
+  <language></language>
+  <type>dataset</type>
+  <title></title>
+  <abstract></abstract>
+  <contact>
+    <name></name>
+    <organization></organization>
+    <position></position>
+    <voice></voice>
+    <fax></fax>
+    <email></email>
+    <role></role>
+  </contact>
+  <links/>
+  <fees></fees>
+  <encoding></encoding>
+  <crs>
+    <spatialrefsys nativeFormat="Wkt">
+      <wkt>PROJCRS["DHDN / 3-degree Gauss-Kruger zone 3",BASEGEOGCRS["DHDN",DATUM["Deutsches Hauptdreiecksnetz",ELLIPSOID["Bessel 1841",6377397.155,299.1528128,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4314]],CONVERSION["3-degree Gauss-Kruger zone 3",METHOD["Transverse Mercator",ID["EPSG",9807]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",9,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["Scale factor at natural origin",1,SCALEUNIT["unity",1],ID["EPSG",8805]],PARAMETER["False easting",3500000,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["northing (X)",north,ORDER[1],LENGTHUNIT["metre",1]],AXIS["easting (Y)",east,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Cadastre, engineering survey, topographic mapping."],AREA["Germany - former West Germany onshore between 7�30'E and 10�30'E - states of Baden-Wurtemberg, Bayern, Bremen, Hamberg, Hessen, Niedersachsen, Nordrhein-Westfalen, Rhineland-Pfalz, Schleswig-Holstein."],BBOX[47.27,7.5,55.09,10.51]],ID["EPSG",31467]]</wkt>
+      <proj4>+proj=tmerc +lat_0=0 +lon_0=9 +k=1 +x_0=3500000 +y_0=0 +ellps=bessel +towgs84=598.1,73.7,418.2,0.202,0.045,-2.455,6.7 +units=m +no_defs</proj4>
+      <srsid>2647</srsid>
+      <srid>31467</srid>
+      <authid>EPSG:31467</authid>
+      <description>DHDN / 3-degree Gauss-Kruger zone 3</description>
+      <projectionacronym>tmerc</projectionacronym>
+      <ellipsoidacronym>EPSG:7004</ellipsoidacronym>
+      <geographicflag>false</geographicflag>
+    </spatialrefsys>
+  </crs>
+  <extent>
+    <spatial maxy="0" dimensions="2" maxx="0" maxz="0" crs="EPSG:31467" miny="0" minz="0" minx="0"/>
+    <temporal>
+      <period>
+        <start></start>
+        <end></end>
+      </period>
+    </temporal>
+  </extent>
+</qgis>

huff/tests/tests_huff.py

@@ -0,0 +1,89 @@
+#-----------------------------------------------------------------------
+# Name:        tests_huff (huff package)
+# Purpose:     Tests for Huff Model package functions
+# Author:      Thomas Wieland 
+#              ORCID: 0000-0001-5168-9846
+#              mail: geowieland@googlemail.com              
+# Version:     1.0.0
+# Last update: 2025-04-25 18:08
+# Copyright (c) 2025 Thomas Wieland
+#-----------------------------------------------------------------------
+
+
+from ..ors import isochrone, matrix
+from ..models import load_geodata, create_interaction_matrix
+
+
+# Isochrones test:
+
+output_path = "."
+
+isochrone_ORS = isochrone (
+    auth = "5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd", 
+    locations =[[7.593301534652711, 47.54329763735186], [9.207916,49.153868]], 
+    save_output = True, 
+    output_filepath = "test.shp", 
+    intersections="false"
+    )
+
+isochrone_ORS.summary()
+
+# Matrix test:
+
+matrix_ORS = matrix(auth="5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd",
+    locations=[[9.70093,48.477473],[9.207916,49.153868],[37.573242,55.801281],[115.663757,38.106467]],
+    save_output=True,
+    output_filepath="testmatrix.csv"
+    )
+
+print(matrix_ORS)
+
+
+# Huff model test data:
+
+Haslach = load_geodata(
+    "huff/tests/data/Haslach.shp",
+    location_type="origins",
+    unique_id="BEZEICHN"
+    )
+
+Haslach.summary()
+
+Haslach.define_marketsize("pop")
+
+Haslach.define_transportcosts_weighting()
+
+Haslach.summary()
+
+
+Haslach_supermarkets = load_geodata(
+    "huff/tests/data/Haslach_supermarkets.shp",
+    location_type="destinations",
+    unique_id="LFDNR"
+    )
+
+Haslach_supermarkets.summary()
+
+Haslach_supermarkets.define_attraction("VKF_qm")
+
+Haslach_supermarkets.define_attraction_weighting()
+
+Haslach_supermarkets.summary()
+
+
+haslach_interactionmatrix = create_interaction_matrix(
+    Haslach,
+    Haslach_supermarkets
+    )
+
+interaction_matrix = haslach_interactionmatrix.transport_costs(
+    ors_auth="5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd"
+    )
+
+interaction_matrix = interaction_matrix.flows()
+
+interaction_matrix.get_interaction_matrix_df().to_excel("interaction_matrix.xlsx")
+
+interaction_matrix.marketareas()
+
+interaction_matrix.summary()

huff-1.0.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.2
+Name: huff
+Version: 1.0.0
+Summary: huff: Huff Model Market Area Analysis
+Author: Thomas Wieland
+Author-email: geowieland@googlemail.com
+Description-Content-Type: text/markdown
+Requires-Dist: geopandas
+Requires-Dist: pandas
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: summary
+
+# huff: Huff Model Market Area Analysis
+
+## Author
+
+Thomas Wieland [ORCID](https://orcid.org/0000-0001-5168-9846) [EMail](mailto:geowieland@googlemail.com) 
+
+See the /tests directory for usage examples of most of the included functions.
+
+
+## Installation
+
+To install the package, use `pip`:
+
+```bash
+pip install huff

huff-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+huff/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+huff/gistools.py,sha256=pyNYiRG_PwjiVlOLY26zPDIGVHE79uwyz48kGQ4k9us,1625
+huff/models.py,sha256=UxFo2laIrNahWrcf-_4xVMO9eR_w7kIBeoG_w_eGD70,21476
+huff/ors.py,sha256=TF1US2Tc1L4ny6-S4JFIkDzgxxrtFsD_N9A-FQBabLM,9397
+huff/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+huff/tests/tests_huff.py,sha256=6L16suvmcYtMBmgppHnhqJSCr6OI1YJh1Bh114ElfUc,2294
+huff/tests/data/Haslach.cpg,sha256=OtMDH1UDpEBK-CUmLugjLMBNTqZoPULF3QovKiesmCQ,5
+huff/tests/data/Haslach.dbf,sha256=GVPIt05OzDO7UrRDcsMhiYWvyXAPg6Z-qkiysFzj-fc,506
+huff/tests/data/Haslach.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2xkEkZyLqmGTY,437
+huff/tests/data/Haslach.qmd,sha256=j9i4_Pz7ZMSG2UDSb3nuhJpw0KWXIRhiiDymqJP6_Fo,2479
+huff/tests/data/Haslach.shp,sha256=s7ks-ukOIKMJCD5x6m0MO6pwkg1USvhudQKTg74ib1E,212
+huff/tests/data/Haslach.shx,sha256=VEMghRPP_HUYIuGoxR7X0eHQe9LnO4s8JP4twfzKyyk,132
+huff/tests/data/Haslach_supermarkets.cpg,sha256=OtMDH1UDpEBK-CUmLugjLMBNTqZoPULF3QovKiesmCQ,5
+huff/tests/data/Haslach_supermarkets.dbf,sha256=4fTBxntDvQ8qFPdGK82ywJd2Xq_9nApDyi3h5_KPFSc,21282
+huff/tests/data/Haslach_supermarkets.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2xkEkZyLqmGTY,437
+huff/tests/data/Haslach_supermarkets.qmd,sha256=j9i4_Pz7ZMSG2UDSb3nuhJpw0KWXIRhiiDymqJP6_Fo,2479
+huff/tests/data/Haslach_supermarkets.shp,sha256=X7QbQ0BTMag_B-bDRbpr-go2BQIXo3Y8zMAKpYZmlps,324
+huff/tests/data/Haslach_supermarkets.shx,sha256=j23QHX-SmdAeN04rw0x8nUOran-OCg_T6r_LvzzEPWs,164
+huff-1.0.0.dist-info/METADATA,sha256=Xl1URHFyO5OqALQcLsBtENr-TNO5cm0b7xo8479hOyg,749
+huff-1.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+huff-1.0.0.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.0.0.dist-info/RECORD,,

huff-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

huff-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+huff