huff 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

huff/gistools.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.0.0
-# Last update: 2025-04-25 18:16
+# Version:     1.1.1
+# Last update: 2025-04-29 18:12
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 

huff/models.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.0.0
-# Last update: 2025-04-25 18:13
+# Version:     1.1.1
+# Last update: 2025-04-29 18:12
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -13,7 +13,9 @@
 import pandas as pd
 import geopandas as gp
 import numpy as np
-from .ors import matrix
+import time
+from huff.ors import Client, TimeDistanceMatrix, Isochrone
+from huff.gistools import overlay_difference
 
 
 class CustomerOrigins:
@@ -198,28 +200,142 @@ class SupplyLocations:
         self.metadata = metadata
 
         return self
+    
+    def add_new_destinations(
+        self,
+        new_destinations,
+        ):
+        
+        geodata_gpd_original = self.get_geodata_gpd_original()
+        geodata_gpd = self.get_geodata_gpd()
+        metadata = self.get_metadata()
+
+        new_destinations_gpd_original = new_destinations.get_geodata_gpd_original()
+        new_destinations_gpd = new_destinations.get_geodata_gpd()
+        new_destinations_metadata = new_destinations.get_metadata()
+
+        if list(new_destinations_gpd_original.columns) != list(geodata_gpd_original.columns):
+            raise KeyError("Supply locations and new destinations data have different column names.")
+        if list(new_destinations_gpd.columns) != list(geodata_gpd.columns):
+            raise KeyError("Supply locations and new destinations data have different column names.")
+
+        geodata_gpd_original = geodata_gpd_original.append(
+            new_destinations_gpd_original, 
+            ignore_index=True
+            )
+        
+        geodata_gpd = geodata_gpd.append(
+            new_destinations_gpd, 
+            ignore_index=True
+            )
+        
+        metadata["no_points"] = metadata["no_points"]+new_destinations_metadata["no_points"]
+        
+        self.geodata_gpd = geodata_gpd
+        self.geodata_gpd_original = geodata_gpd_original
+        self.metadata = metadata
+
+        return self
+    
+    def isochrones(
+        self,
+        segments: list = [900, 600, 300],
+        range_type: str = "time",
+        intersections: str = "true",
+        profile: str = "driving-car",
+        donut: bool = True,
+        ors_server: str = "https://api.openrouteservice.org/v2/",
+        ors_auth: str = None,
+        timeout = 10,
+        delay = 1,
+        save_output: bool = True,
+        output_filepath: str = "isochrones.shp",
+        output_crs: str = "EPSG:4326"
+        ):
+
+        geodata_gpd = self.get_geodata_gpd()
+        metadata = self.get_metadata()
+
+        coords = [(point.x, point.y) for point in geodata_gpd.geometry]
+        
+        unique_id_col = metadata["unique_id"]
+        unique_id_values = geodata_gpd[unique_id_col].values
+
+        ors_client = Client(
+            server = ors_server,
+            auth = ors_auth
+            )
+        
+        isochrones_gdf = gp.GeoDataFrame(columns=[unique_id_col, "geometry"])
+        
+        i = 0
+
+        for x, y in coords:
+            
+            isochrone_output = ors_client.isochrone(
+                locations = [[x, y]],
+                segments = segments,
+                range_type = range_type,
+                intersections = intersections,
+                profile = profile,
+                timeout = timeout,
+                save_output = False,
+                output_crs = output_crs
+                )
+            
+            if isochrone_output.status_code != 200:
+                continue        
+            
+            isochrone_gdf = isochrone_output.get_isochrones_gdf()
+            
+            if donut:
+                isochrone_gdf = overlay_difference(
+                    polygon_gdf = isochrone_gdf, 
+                    sort_col = "segment"
+                    )
+                
+            time.sleep(delay)
+
+            isochrone_gdf[unique_id_col] = unique_id_values[i]
+
+            isochrones_gdf = pd.concat(
+                [
+                    isochrones_gdf, 
+                    isochrone_gdf
+                    ], 
+                ignore_index=True
+                )
+            
+            i = i+1
+
+        isochrones_gdf.set_crs(
+            output_crs, 
+            allow_override=True, 
+            inplace=True
+            )
+            
+        if save_output:
+
+            isochrones_gdf.to_file(filename = output_filepath)
+
+        return isochrones_gdf
 
 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
 
@@ -231,7 +347,7 @@ class InteractionMatrix:
         customer_origins_metadata = self.get_customer_origins().get_metadata()
         supply_locations_metadata = self.get_supply_locations().get_metadata()
 
-        print("Huff Model")
+        print("Huff Model Interaction Matrix")
         print("----------------------------------")
         print("Supply locations   " + str(supply_locations_metadata["no_points"]))
         if supply_locations_metadata["attraction_col"][0] is None:
@@ -259,6 +375,7 @@ class InteractionMatrix:
         self,
         range_type: str = "time",
         time_unit: str = "minutes",
+        ors_server: str = "https://api.openrouteservice.org/v2/",
         ors_auth: str = None,
         save_output: bool = False,
         output_filepath: str = "transport_costs_matrix.csv"
@@ -285,8 +402,11 @@ class InteractionMatrix:
         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,
+        ors_client = Client(
+            server = ors_server,
+            auth = ors_auth
+            )
+        time_distance_matrix = ors_client.matrix(
             locations = locations_coords,
             save_output = save_output,
             output_filepath = output_filepath, 
@@ -295,6 +415,9 @@ class InteractionMatrix:
             range_type = range_type
             )
         
+        if time_distance_matrix.get_metadata() is None:
+            raise ValueError ("No transport costs matrix was built.")
+
         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"]
@@ -339,6 +462,11 @@ class InteractionMatrix:
         if interaction_matrix_df["A_j"].isna().all():
             raise ValueError ("Attraction variable is not defined")
 
+        check_vars(
+            df = interaction_matrix_df,
+            cols = ["A_j", "t_ij"]
+            )
+        
         customer_origins = self.customer_origins
         customer_origins_metadata = customer_origins.get_metadata()
         tc_weighting = customer_origins_metadata["weighting"][0]
@@ -400,6 +528,11 @@ class InteractionMatrix:
         if interaction_matrix_df["C_i"].isna().all():
             raise ValueError ("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
 
+        check_vars(
+            df = interaction_matrix_df,
+            cols = ["C_i"]
+            )
+
         if interaction_matrix_df["p_ij"].isna().all():
             self.probabilities()
             interaction_matrix_df = self.interaction_matrix_df
@@ -413,17 +546,110 @@ class InteractionMatrix:
     def marketareas (self):
 
         interaction_matrix_df = self.interaction_matrix_df
-
+        
+        check_vars(
+            df = interaction_matrix_df,
+            cols = ["E_ij"]
+            )
+        
         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)
+        huff_model = HuffModel(
+            self,
+            market_areas_df
+            )
+        
+        return huff_model
+
+    def mci_transformation(
+        self,
+        cols: list = ["A_j", "t_ij"]
+        ):
 
-        self.market_areas_df = market_areas_df
+        """ MCI model log-centering transformation """
+        
+        cols = cols + ["p_ij"]
+
+        interaction_matrix_df = self.interaction_matrix_df
+
+        interaction_matrix_df = mci_transformation(
+            df = interaction_matrix_df,
+            ref_col = "i",
+            cols = cols
+            )
+        
+        self.interaction_matrix_df = interaction_matrix_df
 
         return self
 
+class HuffModel:
+
+    def __init__(
+        self,
+        interaction_matrix, 
+        market_areas_df
+        ):
+
+        self.interaction_matrix = interaction_matrix
+        self.market_areas_df = market_areas_df
+
+    def get_interaction_matrix_df(self):
+
+        interaction_matrix = self.interaction_matrix
+        interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
+
+        return interaction_matrix_df
+    
+    def get_supply_locations(self):
+
+        interaction_matrix = self.interaction_matrix
+        supply_locations = interaction_matrix.get_supply_locations()
+
+        return supply_locations
+
+    def get_customer_origins(self):
+
+        interaction_matrix = self.interaction_matrix
+        customer_origins = interaction_matrix.get_customer_origins()
+
+        return customer_origins
+
+    def get_market_areas_df(self):
+        return self.market_areas_df
+    
+    def summary(self):
+
+        interaction_matrix = self.interaction_matrix
+
+        customer_origins_metadata = interaction_matrix.get_customer_origins().get_metadata()
+        supply_locations_metadata = interaction_matrix.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 load_geodata (
     file, 
     location_type: str, 
@@ -438,7 +664,7 @@ def load_geodata (
     ):
 
     if location_type is None or (location_type != "origins" and location_type != "destinations"):
-        raise ValueError ("location_type must be either 'loc' or 'dest'")
+        raise ValueError ("location_type must be either 'origins' or 'destinations'")
     
     if data_type not in ["shp", "csv", "xlsx"]:
         raise ValueError ("data_type must be 'shp', 'csv' or 'xlsx'")
@@ -517,7 +743,7 @@ def create_interaction_matrix(
     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")
+        raise ValueError ("supply_locations must be of class SupplyLocations")
 
     customer_origins_metadata = customer_origins.get_metadata()
     if customer_origins_metadata["marketsize_col"] is None:
@@ -573,13 +799,53 @@ def create_interaction_matrix(
     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
+    return interaction_matrix
+
+def check_vars(
+    df: pd.DataFrame,
+    cols: list
+    ):
+
+    for col in cols:
+        if col not in df.columns:
+            raise KeyError(f"Column '{col}' not in dataframe.")
+    
+    for col in cols:
+        if not pd.api.types.is_numeric_dtype(df[col]):
+            raise ValueError(f"Column '{col}' is not numeric. All columns must be numeric.")
+    
+    for col in cols:
+        if (df[col] <= 0).any():
+            raise ValueError(f"Column '{col}' includes values <= 0. All values must be numeric and positive.")
+
+def mci_transformation(
+    df: pd.DataFrame,
+    ref_col: str,
+    cols: list
+    ):
+   
+    check_vars(
+        df = df,
+        cols = cols + [ref_col]
+        )
+
+    def lct (x):
+
+        x_geom = np.exp(np.log(x).mean())
+        x_lct = np.log(x/x_geom)
+
+        return x_lct
+    
+    for var in cols:
+
+        var_t = df.groupby(ref_col)[var].apply(lct)
+        var_t = var_t.reset_index()
+        df[var+"_t"] = var_t[var]
+
+    return df

huff/ors.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.0.0
-# Last update: 2025-04-25 18:14
+# Version:     1.1.1
+# Last update: 2025-04-29 18:12
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -32,22 +32,31 @@ class Isochrone:
         self.status_code = status_code
         self.save_config = save_config
 
+    def get_isochrones_gdf(self):
+
+        isochrones_gdf = self.isochrones_gdf
+        return isochrones_gdf
+
     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))
+        if metadata is not None:
+            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"])
 
+            print("Locations    " + str(no_locations))
+            print("Segments     " + ", ".join(range_str))
+            print("Range type   " + range_type)
+            print("Profile      " + profile)
+            
+        else:
+            print("No isochrones were built.")
+        
+        print("Status code  " + str(status_code))
 
 class TimeDistanceMatrix:
 
@@ -81,254 +90,294 @@ class TimeDistanceMatrix:
         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
-            )
+        config = self.save_config
+
+        if metadata is not None:
+
+            profile = metadata["query"]["profile"]
+            no_locations = len(metadata["query"]["locations"])
+            range_type = config["range_type"]
+
+            print("Locations    " + str(no_locations))
+            print("Range type   " + range_type)
+            print("Profile      " + profile)
+        else:
+            print("No time/distance matrix was built.")
+        print("Status code  " + str(status_code))
+
+class Client:
+
+    def __init__(
+        self,
+        server = "https://api.openrouteservice.org/v2/",
+        auth: str = None
+        ):
         
-    except:
+        self.server = server
+        self.auth = auth
+            
+    def isochrone(
+        self,
+        locations: list,
+        id: list = [],
+        segments: list = [900, 600, 300],
+        range_type: str = "time",
+        intersections: str = "true",
+        profile: str = "driving-car",
+        timeout = 10,
+        save_output: bool = True,
+        output_filepath: str = "isochrones.shp",
+        output_crs: str = "EPSG:4326"
+        ):
+
+        ors_url = self.server + "isochrones/" + profile
+        auth = self.auth
+
+        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
+        }
+
+        save_config = {
+            "range_type": range_type,
+            "save_output": save_output,
+            "output_filepath" : output_filepath,
+            "output_crs": output_crs
+            }
+
+        try:
+
+            response = requests.post(
+                ors_url, 
+                headers=headers, 
+                json=body,
+                timeout=timeout
+                )
+            
+        except:
 
-        if verbose is True:
             print ("Unknown error while accessing ORS server")
-        
-        status_code = 99999
-        isochrones_gdf = None 
-        metadata = None
+            
+            status_code = 99999
+            isochrones_gdf = None 
+            metadata = None
+
+            isochrone_output = Isochrone(
+                isochrones_gdf, 
+                metadata,
+                status_code,
+                save_config
+                )
+            
+            return isochrone_output
 
-    status_code = response.status_code
+        status_code = response.status_code
 
-    if status_code == 200:
+        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]
+            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 = gp.GeoDataFrame(
+                features, 
+                geometry=geometries, 
+                crs="EPSG:4326"
+                )
 
-        isochrones_gdf["segment"] = 0
-        isochrones_gdf_properties_dict = dict(isochrones_gdf["properties"])
+            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"]
+            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)
+            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)
+            if save_output:
+                isochrones_gdf.to_file(output_filepath)
+                print ("Saved as", output_filepath)
 
-    else:
+        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:
+            isochrones_gdf = None
+            metadata = None
         
-        if verbose is True:
-            print ("Unknown error while accessing ORS server")
-        
-        status_code = 99999
-        matrix_df = None
-        metadata = None
+        isochrone_output = Isochrone(
+            isochrones_gdf, 
+            metadata,
+            status_code,
+            save_config
+            )
         
-    status_code = response.status_code
+        return isochrone_output
+
+    def matrix(
+        self,
+        locations: list,
+        sources: list = [],
+        destinations: list = [],
+        id: str = None,
+        range_type = "time",
+        profile = "driving-car",
+        metrics: list = [],
+        resolve_locations: bool = False,    
+        units: str = "mi",
+        timeout = 10,
+        save_output = False,
+        output_filepath = "matrix.csv",
+        csv_sep = ";",
+        csv_decimal = ",",
+        csv_encoding = None
+        ):
 
-    if status_code == 200:
+        ors_url = self.server + "matrix/" + profile
+        auth = self.auth
 
-        if verbose is True:
-            print ("Accessing ORS server successful")
+        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
+
+        save_config = {
+            "range_type": range_type,
+            "save_output": save_output,
+            "output_filepath": output_filepath
+        }
 
-        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"]
+        try:
+
+            response = requests.post(
+                ors_url, 
+                headers=headers, 
+                json=body,
+                timeout=timeout
+                )
+            
+        except:
+            
+            print ("Unknown error while accessing ORS server")
             
-            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
+            status_code = 99999
+            matrix_df = None
+            metadata = None
+
+            matrix_output = TimeDistanceMatrix(
+                matrix_df, 
+                metadata,
+                status_code,
+                save_config
                 )
-            print ("Saved as", output_filepath)
 
-    else:
+            return matrix_output
 
-        if verbose is True:
-            print ("Error in accessing ORS server. Status Code: " + str(status_code))
+        status_code = response.status_code
 
-        matrix_df = None
-        metadata = None
+        if status_code == 200:
 
-    save_config = {
-        "range_type": range_type,
-        "save_output": save_output,
-        "output_filepath": output_filepath
-    }
+            print ("Accessing ORS server successful")
 
-    matrix_output = TimeDistanceMatrix(
-        matrix_df, 
-        metadata,
-        status_code,
-        save_config
-        )
-    
-    return matrix_output
+            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:
+
+            print ("Error in accessing ORS server. Status Code: " + str(status_code))
+
+            matrix_df = None
+            metadata = None
+
+        matrix_output = TimeDistanceMatrix(
+            matrix_df, 
+            metadata,
+            status_code,
+            save_config
+            )
+        
+        return matrix_output

huff/tests/tests_huff.py

@@ -4,25 +4,28 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.0.0
-# Last update: 2025-04-25 18:08
+# Version:     1.1.1
+# Last update: 2025-04-29 18:12
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
 
-from ..ors import isochrone, matrix
-from ..models import load_geodata, create_interaction_matrix
+from huff.ors import Client
+from huff.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]], 
+ors_client = Client(
+    auth = "5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd"
+    )
+
+isochrone_ORS = ors_client.isochrone (
+    locations = [[7.593301534652711, 47.54329763735186], [9.207916,49.153868]], 
     save_output = True, 
-    output_filepath = "test.shp", 
+    output_filepath = "test_isochrones.shp", 
     intersections="false"
     )
 
@@ -30,19 +33,19 @@ isochrone_ORS.summary()
 
 # Matrix test:
 
-matrix_ORS = matrix(auth="5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd",
+matrix_ORS = ors_client.matrix(
     locations=[[9.70093,48.477473],[9.207916,49.153868],[37.573242,55.801281],[115.663757,38.106467]],
     save_output=True,
-    output_filepath="testmatrix.csv"
+    output_filepath="test_matrix.csv"
     )
 
-print(matrix_ORS)
+matrix_ORS.summary()
 
 
 # Huff model test data:
 
 Haslach = load_geodata(
-    "huff/tests/data/Haslach.shp",
+    "data/Haslach.shp",
     location_type="origins",
     unique_id="BEZEICHN"
     )
@@ -51,22 +54,32 @@ Haslach.summary()
 
 Haslach.define_marketsize("pop")
 
-Haslach.define_transportcosts_weighting()
+Haslach.define_transportcosts_weighting(
+    param_lambda=-2.2
+    )
 
 Haslach.summary()
 
 
 Haslach_supermarkets = load_geodata(
-    "huff/tests/data/Haslach_supermarkets.shp",
+    "data/Haslach_supermarkets.shp",
     location_type="destinations",
     unique_id="LFDNR"
     )
 
 Haslach_supermarkets.summary()
 
+Haslach_supermarkets.isochrones(
+    save_output=True,
+    ors_auth = "5b3ce3597851110001cf62480a15aafdb5a64f4d91805929f8af6abd",
+    output_filepath="Haslach_supermarkets_iso.shp"
+    )
+
 Haslach_supermarkets.define_attraction("VKF_qm")
 
-Haslach_supermarkets.define_attraction_weighting()
+Haslach_supermarkets.define_attraction_weighting(
+    param_gamma=0.9
+    )
 
 Haslach_supermarkets.summary()
 
@@ -82,8 +95,8 @@ interaction_matrix = haslach_interactionmatrix.transport_costs(
 
 interaction_matrix = interaction_matrix.flows()
 
-interaction_matrix.get_interaction_matrix_df().to_excel("interaction_matrix.xlsx")
+huff_model = interaction_matrix.marketareas()
 
-interaction_matrix.marketareas()
+print(interaction_matrix.get_interaction_matrix_df())
 
-interaction_matrix.summary()
+print(huff_model.get_market_areas_df())

huff-1.1.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: huff
+Version: 1.1.1
+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
+
+# 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.
+
+
+## Features
+
+- **Huff Model**: 
+  - Defining origins and destinations with weightings
+  - Creating interaction matrix from origins and destinations
+  - Calculating basic Huff Model
+- **Multiplicative Competitive Interaction Model**: 
+  - Log-centering transformation
+- **OpenRouteService Client** (Tools via API): 
+  - Creating transport costs matrix from origins and destinations
+  - Creating isochrones from destinations
+
+Attribution of OpenRouteService:
+© openrouteservice.org by HeiGIT | Map data © OpenStreetMap contributors
+Visit https://openrouteservice.org/
+
+## Literature
+  - Huff DL (1962) *Determination of Intra-Urban Retail Trade Areas*.
+  - Huff DL (1964) Defining and estimating a trading area. *Journal of Marketing* 28(4): 34–38. [10.2307/1249154](https://doi.org/10.2307/1249154)
+  - Huff DL, McCallum BM (2008) Calibrating the Huff Model using ArcGIS Business Analyst. ESRI White Paper, September 2008. https://www.esri.com/library/whitepapers/pdfs/calibrating-huff-model.pdf. 
+  - De Beule M, Van den Poel D, Van de Weghe N (2014) An extended Huff-model for robustly benchmarking and predicting retail network performance. *Applied Geography*,* 46(1): 80–89. [10.1016/j.apgeog.2013.09.026](https://doi.org/10.1016/j.apgeog.2013.09.026) 
+  - Nakanishi M, Cooper LG (1974) Parameter estimation for a Multiplicative Competitive Interaction Model: Least squares approach. *Journal of Marketing Research* 11(3): 303–311. [10.2307/3151146](https://doi.org/10.2307/3151146).
+  - Wieland T (2017) Market Area Analysis for Retail and Service Locations with MCI. *R Journal* 9(1): 298-323. [10.32614/RJ-2017-020](https://doi.org/10.32614/RJ-2017-020)
+  - Wieland T (2018) A Hurdle Model Approach of Store Choice and Market Area Analysis in Grocery Retailing. *Papers in Applied Geography* 4(4): 370-389. [10.1080/23754931.2018.1519458](https://doi.org/10.1080/23754931.2018.1519458)
+
+
+## Installation
+
+To install the package, use `pip`:
+
+```bash
+pip install huff

{huff-1.0.0.dist-info → huff-1.1.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 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/gistools.py,sha256=YgkuVbNTupIDybGnLQZ4oeEjPhoFtXo132ehbdZ_thk,1625
+huff/models.py,sha256=5_0ZBYz9Pa6ZA2MErJI4YwnZrcIDp3_K6V8UnWGrhuE,30258
+huff/ors.py,sha256=JKJyEttW4LPVzv3xQhl6cRT8KQjrLaVNpbckeQdLDWE,11467
 huff/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-huff/tests/tests_huff.py,sha256=6L16suvmcYtMBmgppHnhqJSCr6OI1YJh1Bh114ElfUc,2294
+huff/tests/tests_huff.py,sha256=5csNqE-9_cdNU1wuOQ5CV5bni1S546e24QZo6XMsct0,2515
 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
@@ -16,7 +16,7 @@ huff/tests/data/Haslach_supermarkets.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2x
 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.1.1.dist-info/METADATA,sha256=6aprnoJS3msu7tBJts1j2lBvb1UFriCnZj-uXPUaAZU,2539
+huff-1.1.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huff-1.1.1.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.1.1.dist-info/RECORD,,

{huff-1.0.0.dist-info → huff-1.1.1.dist-info}/WHEEL

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

huff-1.0.0.dist-info/METADATA

@@ -1,32 +0,0 @@
-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