huff 1.0.0__py3-none-any.whl → 1.1.0__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.0
+# Last update: 2025-04-28 19:36
 # 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.0
+# Last update: 2025-04-28 19:35
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -13,7 +13,7 @@
 import pandas as pd
 import geopandas as gp
 import numpy as np
-from .ors import matrix
+from huff.ors import Client
 
 
 class CustomerOrigins:
@@ -198,28 +198,54 @@ 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()
+
+        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
 
 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 +257,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 +285,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 +312,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 +325,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"]
@@ -418,12 +451,98 @@ class InteractionMatrix:
         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
 
-        self.market_areas_df = market_areas_df
+    def mci_transformation(
+        self,
+        cols = ["A_j", "t_ij"]
+        ):
+        
+        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 +557,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 +636,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 +692,31 @@ 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 mci_transformation(
+    df: pd.DataFrame,
+    ref_col: str,
+    cols: list
+    ):
+   
+    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.0
+# Last update: 2025-04-26 19:35
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -37,17 +37,21 @@ class Isochrone:
         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 +85,298 @@ 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
-            )
-        
-    except:
+        config = self.save_config
 
-        if verbose is True:
-            print ("Unknown error while accessing ORS server")
-        
-        status_code = 99999
-        isochrones_gdf = None 
-        metadata = None
+        if metadata is not None:
 
-    status_code = response.status_code
+            profile = metadata["query"]["profile"]
+            no_locations = len(metadata["query"]["locations"])
+            range_type = config["range_type"]
 
-    if status_code == 200:
+            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))
 
-        if verbose is True:
-            print ("Accessing ORS server successful")
+class Client:
 
-        response_json = response.json()
-        
-        metadata = response_json["metadata"]
+    def __init__(
+        self,
+        server = "https://api.openrouteservice.org/v2/",
+        auth: str = None
+        ):
         
-        features = response_json["features"]
-        geometries = [shape(feature["geometry"]) for feature in features]
+        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",
+        save_output: bool = True,
+        output_filepath: str = "isochrones.shp",
+        output_crs: str = "EPSG:2056",
+        verbose: bool = True
+        ):
 
-        isochrones_gdf = gp.GeoDataFrame(
-            features, 
-            geometry=geometries, 
-            crs="EPSG:4326"
-            )
+        ors_url = self.server + "isochrones/" + profile
+        auth = self.auth
 
-        isochrones_gdf["segment"] = 0
-        isochrones_gdf_properties_dict = dict(isochrones_gdf["properties"])
+        headers = {
+            "Content-Type": "application/json; charset=utf-8",
+            "Accept": "application/json, application/geo+json, application/gpx+xml, img/png; charset=utf-8",
+            "Authorization": auth
+        }
 
-        for i in range(len(isochrones_gdf_properties_dict)):
-            isochrones_gdf.iloc[i,3] = isochrones_gdf_properties_dict[i]["value"]
+        body = {
+            "locations": locations,
+            "range": segments,
+            "intersections": intersections,
+            "range_type": range_type
+        }
 
-        isochrones_gdf = isochrones_gdf.drop(columns=["properties"])
-        isochrones_gdf = isochrones_gdf.to_crs(output_crs)
+        save_config = {
+            "range_type": range_type,
+            "save_output": save_output,
+            "output_filepath" : output_filepath,
+            "output_crs": output_crs
+            }
 
-        if save_output:
-            isochrones_gdf.to_file(output_filepath)
-            print ("Saved as", output_filepath)
+        try:
 
-    else:
+            response = requests.post(
+                ors_url, 
+                headers=headers, 
+                json=body
+                )
+            
+        except:
 
-        if verbose is True:
-            print ("Error while accessing ORS server. Status Code: " + str(status_code))
+            if verbose is True:
+                print ("Unknown error while accessing ORS server")
+            
+            status_code = 99999
+            isochrones_gdf = None 
+            metadata = None
+
+            isochrone_output = Isochrone(
+                isochrones_gdf, 
+                metadata,
+                status_code,
+                save_config
+                )
+            
+            return isochrone_output
 
-        isochrones_gdf = None
-        metadata = None
+        status_code = response.status_code
 
-    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 status_code == 200:
+            if verbose is True:
+                print ("Accessing ORS server successful")
 
-        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()
+            isochrones_gdf = gp.GeoDataFrame(
+                features, 
+                geometry=geometries, 
+                crs="EPSG:4326"
+                )
 
-        metadata = response_json["metadata"]
+            isochrones_gdf["segment"] = 0
+            isochrones_gdf_properties_dict = dict(isochrones_gdf["properties"])
 
-        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 in range(len(isochrones_gdf_properties_dict)):
+                isochrones_gdf.iloc[i,3] = isochrones_gdf_properties_dict[i]["value"]
 
-        for i, value in enumerate(response_json["durations"]):
+            isochrones_gdf = isochrones_gdf.drop(columns=["properties"])
+            isochrones_gdf = isochrones_gdf.to_crs(output_crs)
 
-            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)
+            if save_output:
+                isochrones_gdf.to_file(output_filepath)
+                print ("Saved as", output_filepath)
 
-    else:
+        else:
 
-        if verbose is True:
-            print ("Error in accessing ORS server. Status Code: " + str(status_code))
+            if verbose is True:
+                print ("Error while accessing ORS server. Status Code: " + str(status_code))
 
-        matrix_df = None
-        metadata = None
+            isochrones_gdf = None
+            metadata = None
+        
+        isochrone_output = Isochrone(
+            isochrones_gdf, 
+            metadata,
+            status_code,
+            save_config
+            )
+        
+        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",
+        save_output = False,
+        output_filepath = "matrix.csv",
+        csv_sep = ";",
+        csv_decimal = ",",
+        csv_encoding = None,
+        verbose = True
+        ):
 
-    save_config = {
-        "range_type": range_type,
-        "save_output": save_output,
-        "output_filepath": output_filepath
-    }
+        ors_url = self.server + "matrix/" + profile
+        auth = self.auth
 
-    matrix_output = TimeDistanceMatrix(
-        matrix_df, 
-        metadata,
-        status_code,
-        save_config
-        )
-    
-    return matrix_output
+        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
+        }
+
+        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
+
+            matrix_output = TimeDistanceMatrix(
+                matrix_df, 
+                metadata,
+                status_code,
+                save_config
+                )
+
+            return matrix_output
+
+        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
+
+        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.0
+# Last update: 2025-04-28 19:36
 # 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,13 +54,15 @@ 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"
     )
@@ -66,7 +71,9 @@ Haslach_supermarkets.summary()
 
 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 +89,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.0.0.dist-info → huff-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: huff
-Version: 1.0.0
+Version: 1.1.0
 Summary: huff: Huff Model Market Area Analysis
 Author: Thomas Wieland
 Author-email: geowieland@googlemail.com
@@ -8,12 +8,6 @@ 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
 

{huff-1.0.0.dist-info → huff-1.1.0.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=S-C2wjHWtdkpUtxMEKznJp0fCi4GwB8IBRYtuiqnmGg,1625
+huff/models.py,sha256=tjriIk9EaAWbgrll8Z1bFjFCwD9UgsBuoVfqUMUbGME,26275
+huff/ors.py,sha256=XtRn6gtR1P1VmIBsflzDDu6_GLWwCg-Gdl_cogQnX-o,11515
 huff/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-huff/tests/tests_huff.py,sha256=6L16suvmcYtMBmgppHnhqJSCr6OI1YJh1Bh114ElfUc,2294
+huff/tests/tests_huff.py,sha256=rfZ-Iv6cFl9rzlbQxS7sSVf2BgornW-764cEpCoQgoE,2321
 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.0.dist-info/METADATA,sha256=wKaC8cqy3oc20SAhIz5fYw0IdXOJCEP_T8KkiqQPS34,610
+huff-1.1.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huff-1.1.0.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.1.0.dist-info/RECORD,,

{huff-1.0.0.dist-info → huff-1.1.0.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