Update app.py

app.py

@@ -82,6 +82,7 @@ def test(input_json):
     
     matrix = inputs['input']["matrix"]
     landuses = inputs['input']["landuse_areas"]
+    transport_matrix = inputs['input']["transportMatrix"]  
     #attributeMapperDict = inputs['input']["attributeMapperDict"]
     #landuseMapperDict = inputs['input']["landuseMapperDict"]
     
@@ -91,14 +92,34 @@ def test(input_json):
     threshold = float(threshold)
     
     df_matrix = pd.DataFrame(matrix).T
-    df_landuses = pd.DataFrame(landuses).T
     df_matrix = df_matrix.round(0).astype(int)
+
+    df_landuses = pd.DataFrame(landuses).T
     df_landuses = df_landuses.round(0).astype(int)
+    
+
 
 
+    """
+    # List containing the substrings to check against
+    tranportModes = ["DRT", "GMT", "HSR"]
+    
+    # Initialize a dictionary to hold the categorized sub-dictionaries
+    result_dict = {mode: {} for mode in tranportModes}
+    
+    # Iterate over the original dictionary to split into sub-dictionaries based on substrings
+    for key, value in transport_matrix.items():
+        for mode in tranportModes:
+            if mode in key:  # Check if the substring is in the dictionary key
+                result_dict[substring][key] = value
+    
 
 
     
+    df_transport_matrix = pd.DataFrame(transport_matrix).T
+    df_transport_matrix = df_transport_matrix.round(0).astype(int)    
+    """
+    
     # create a mask based on the matrix size and ids, crop activity nodes to the mask
     mask_connected = df_matrix.index.tolist()
 
@@ -141,6 +162,8 @@ def test(input_json):
 
     
     
+    
+    
     def landusesToSubdomains(DistanceMatrix, LanduseDf, LanduseToSubdomainDict, UniqueSubdomainsList):
         df_LivabilitySubdomainsArea = pd.DataFrame(0, index=DistanceMatrix.index, columns=UniqueSubdomainsList)
     
@@ -200,10 +223,11 @@ def test(input_json):
         
         return subdomainsAccessibility
     
-    subdomainsAccessibility = computeAccessibility(df_matrix,LivabilitySubdomainsInputs,alpha,threshold)
-
-
-
+    subdomainsAccessibility = computeAccessibility(df_matrix,LivabilitySubdomainsInputs,alpha,threshold)   
+    transportAccessibility = computeAccessibility(df_transport_matrix,None,alpha,threshold)
+    
+    AccessibilityInputs = pd.concat([subdomainsAccessibility, transportAccessibility], axis=1)
+    
 
     def remap(value, B_min, B_max, C_min, C_max):
         return C_min + (((value - B_min) / (B_max - B_min))* (C_max - C_min))    
@@ -214,17 +238,15 @@ def test(input_json):
 
     
     
-    def accessibilityToLivability (DistanceMatrix,subdomainsAccessibility, SubdomainAttributeDict,UniqueDomainsList):
+    def accessibilityToLivability (DistanceMatrix,AccessibilityInputs, SubdomainAttributeDict,UniqueDomainsList):
     
-        livability = pd.DataFrame(index=DistanceMatrix.index, columns=subdomainsAccessibility.columns)
+        livability = pd.DataFrame(index=DistanceMatrix.index, columns=AccessibilityInputs.columns)
                              
         for domain in UniqueDomainsList:
             livability[domain] = 0
             
         livability.fillna(0, inplace=True)
         
-        #livability.drop(columns='Workplaces', inplace=True)
-
         templist = []
         # remap accessibility to livability points
         
@@ -234,29 +256,21 @@ def test(input_json):
             domains = [str(item) for item in SubdomainAttributeDict[key]['domain']]
         
             if key in subdomainsAccessibility.columns and key != 'commercial':
-                livability_score = remap(subdomainsAccessibility[key], 0, threshold, 0, max_livability)
-                livability.loc[subdomainsAccessibility[key] >= threshold, key] = max_livability
-                livability.loc[subdomainsAccessibility[key] < threshold, key] = livability_score          
+                livability_score = remap(AccessibilityInputs[key], 0, threshold, 0, max_livability)
+                livability.loc[AccessibilityInputs[key] >= threshold, key] = max_livability
+                livability.loc[AccessibilityInputs[key] < threshold, key] = livability_score          
                 if any(domains):
                     for domain in domains:
                         if domain != 'Workplaces':
-                            livability.loc[subdomainsAccessibility[key] >= threshold, domain] += max_livability
-                            livability.loc[subdomainsAccessibility[key] < threshold, domain] += livability_score
-                
-                                
+                            livability.loc[AccessibilityInputs[key] >= threshold, domain] += max_livability
+                            livability.loc[AccessibilityInputs[key] < threshold, domain] += livability_score
+                                                
             elif key == 'commercial':
-                livability_score = remap(subdomainsAccessibility['jobs'], 0, threshold, 0, max_livability)
-                livability.loc[subdomainsAccessibility['jobs'] >= threshold, domains[0]] = max_livability
-                livability.loc[subdomainsAccessibility['jobs'] < threshold, domains[0]] = livability_score
-
-                """
-                for value in subdomainsAccessibility['jobs']:
-                    if value >= threshold:
-                        templist.append(max_livability)
-                    else:
-                        templist.append(livability_score)
-        #livability = livability.rename(columns={'jobs': 'Workplaces'})
-"""
+                livability_score = remap(AccessibilityInputs['jobs'], 0, threshold, 0, max_livability)
+                livability.loc[AccessibilityInputs['jobs'] >= threshold, domains[0]] = max_livability
+                livability.loc[AccessibilityInputs['jobs'] < threshold, domains[0]] = livability_score
+
+        
         return livability