Improve multi distance calculator

apps/multi_points_distance_calculator.py

@@ -15,16 +15,16 @@ st.write(
 dataset1_sample_file_path = "samples/Dataset1.xlsx"
 dataset2_sample_file_path = "samples/Dataset2.xlsx"
 
-col1, col2, col3 = st.columns(3)
+download_col1, download_col2 = st.columns(2)
 
-with col1:
+with download_col1:
     st.download_button(
         label="Dataset1 Sample File",
         data=open(dataset1_sample_file_path, "rb").read(),
         file_name="Dataset1.xlsx",
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
     )
-with col2:
+with download_col2:
     st.download_button(
         label="Dataset2 Sample File",
         data=open(dataset2_sample_file_path, "rb").read(),
@@ -32,51 +32,98 @@ with col2:
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
     )
 
+upload_data1_col, upload_data2_col = st.columns(2)
 
-# Upload Dataset 1
-st.subheader("Upload Dataset 1 (Reference Points)")
-file1 = st.file_uploader("Upload first dataset (Excel)", type=["xlsx"], key="file1")
+with upload_data1_col:
+    # Upload Dataset 1
+    st.subheader("Upload Dataset 1 (Reference Points)")
+    file1 = st.file_uploader("Upload first dataset (Excel)", type=["xlsx"], key="file1")
+
+with upload_data2_col:
+    # Upload Dataset 2
+    st.subheader("Upload Dataset 2 (Comparison Points)")
+    file2 = st.file_uploader(
+        "Upload second dataset (Excel)", type=["xlsx"], key="file2"
+    )
 
-# Upload Dataset 2
-st.subheader("Upload Dataset 2 (Comparison Points)")
-file2 = st.file_uploader("Upload second dataset (Excel)", type=["xlsx"], key="file2")
 
 if file1 and file2:
+    param_col1, param_col2 = st.columns(2)
     try:
         # Read the datasets
         df1 = pd.read_excel(file1)
         df2 = pd.read_excel(file2)
 
-        st.subheader("Select Columns for Dataset 1")
-        code_col1 = st.selectbox("Select 'CODE' Column", df1.columns, key="code1")
-        lat_col1 = st.selectbox("Select 'Latitude' Column", df1.columns, key="lat1")
-        long_col1 = st.selectbox("Select 'Longitude' Column", df1.columns, key="long1")
-
-        st.subheader("Select Columns for Dataset 2")
-        code_col2 = st.selectbox("Select 'CODE' Column", df2.columns, key="code2")
-        lat_col2 = st.selectbox("Select 'Latitude' Column", df2.columns, key="lat2")
-        long_col2 = st.selectbox("Select 'Longitude' Column", df2.columns, key="long2")
+        with param_col1:
+            st.subheader("Select Columns for Dataset 1")
+            code_col1 = st.selectbox("Select 'CODE' Column", df1.columns, key="code1")
+            lat_col1 = st.selectbox("Select 'Latitude' Column", df1.columns, key="lat1")
+            long_col1 = st.selectbox(
+                "Select 'Longitude' Column", df1.columns, key="long1"
+            )
 
+        with param_col2:
+            st.subheader("Select Columns for Dataset 2")
+            code_col2 = st.selectbox("Select 'CODE' Column", df2.columns, key="code2")
+            lat_col2 = st.selectbox("Select 'Latitude' Column", df2.columns, key="lat2")
+            long_col2 = st.selectbox(
+                "Select 'Longitude' Column", df2.columns, key="long2"
+            )
+        min_distance = st.number_input(
+            "Minimum Distance (km)", min_value=0.0, value=5.0
+        )
         # Calculate distances when button is clicked
         if st.button("Calculate Distances"):
-            df_distances, df_closest = calculate_distances(
-                df1, df2, code_col1, lat_col1, long_col1, code_col2, lat_col2, long_col2
+            df_distances, df_closest, df_closest_min_distance = calculate_distances(
+                df1,
+                df2,
+                code_col1,
+                lat_col1,
+                long_col1,
+                code_col2,
+                lat_col2,
+                long_col2,
+                min_distance,
             )
 
-            # Display all distances
-            st.subheader("All Distances")
-            st.dataframe(df_distances)
+            # # Display all distances
+            # st.subheader("All Distances")
+            # st.dataframe(df_distances)
 
             # Display closest points
             st.subheader("Closest Matches")
             st.dataframe(df_closest)
+            st.subheader("Closest Matches below Min Distance")
+            st.dataframe(df_closest_min_distance)
 
-            # Downloadable CSV
+            # Downloadable All distances CSV
+            st.download_button(
+                label="Download All Distances as CSV",
+                data=df_distances.to_csv(index=False),
+                file_name="all_distances.csv",
+                mime="text/csv",
+                on_click="ignore",
+                type="primary",
+            )
+
+            # Downloadable Closest matches CSV
             st.download_button(
                 label="Download Closest Matches as CSV",
                 data=df_closest.to_csv(index=False),
                 file_name="closest_matches.csv",
                 mime="text/csv",
+                on_click="ignore",
+                type="primary",
+            )
+
+            # Downloadable Closest matches below Min Distance CSV
+            st.download_button(
+                label=f"Download Closest Matches below {min_distance}km as CSV",
+                data=df_closest_min_distance.to_csv(index=False),
+                file_name=f"closest_matches_{min_distance}km.csv",
+                mime="text/csv",
+                on_click="ignore",
+                type="primary",
             )
 
     except Exception as e:

utils/utils_functions.py

@@ -1,41 +1,126 @@
+import warnings
+
 import pandas as pd
 from geopy.distance import geodesic
 
-
 # Function to calculate distances while preserving all original columns
+# def calculate_distances(
+#     df1: pd.DataFrame,
+#     df2: pd.DataFrame,
+#     code_col1,
+#     lat_col1,
+#     long_col1,
+#     code_col2,
+#     lat_col2,
+#     long_col2,
+#     min_distance: int = 1,
+# ):
+#     distances = []
+
+#     for _, row1 in df1.iterrows():
+#         for _, row2 in df2.iterrows():
+#             coord1 = (row1[lat_col1], row1[long_col1])
+#             coord2 = (row2[lat_col2], row2[long_col2])
+#             distance_km = geodesic(coord1, coord2).kilometers  # Compute distance
+
+#             # Combine all original columns + distance
+#             combined_row = {
+#                 **row1.to_dict(),  # Keep all columns from Dataset1
+#                 **{
+#                     f"{col}_Dataset2": row2[col] for col in df2.columns
+#                 },  # Keep all columns from Dataset2
+#                 "Distance_km": distance_km,
+#             }
+#             distances.append(combined_row)
+
+#     df_distances = pd.DataFrame(distances)
+
+#     # Find the closest point for each Point1
+#     df_closest: pd.DataFrame = df_distances.loc[
+#         df_distances.groupby(code_col1)["Distance_km"].idxmin()
+#     ]
+
+#     # Find the distnce below min_distance
+#     df_closest_min_distance = df_distances[df_distances["Distance_km"] < min_distance]
+
+#     return df_distances, df_closest, df_closest_min_distance
+
+
 def calculate_distances(
     df1: pd.DataFrame,
     df2: pd.DataFrame,
-    code_col1,
-    lat_col1,
-    long_col1,
-    code_col2,
-    lat_col2,
-    long_col2,
-):
+    code_col1: str,
+    lat_col1: str,
+    long_col1: str,
+    code_col2: str,
+    lat_col2: str,
+    long_col2: str,
+    min_distance: float = 1.0,
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """
+    Calculate distances between points in two datasets and find closest matches.
+
+    Args:
+        df1: First DataFrame containing reference points
+        df2: Second DataFrame containing points to compare
+        code_col1: Column name in df1 containing point identifiers
+        lat_col1: Column name in df1 containing latitude
+        long_col1: Column name in df1 containing longitude
+        code_col2: Column name in df2 containing point identifiers
+        lat_col2: Column name in df2 containing latitude
+        long_col2: Column name in df2 containing longitude
+        min_distance: Minimum distance threshold in kilometers
+
+    Returns:
+        tuple: (all_distances, closest_matches, matches_below_threshold)
+    """
+    # Validate input columns
+    required_cols_1 = {code_col1, lat_col1, long_col1}
+    required_cols_2 = {code_col2, lat_col2, long_col2}
+
+    if not required_cols_1.issubset(df1.columns):
+        raise ValueError(
+            f"df1 is missing required columns: {required_cols_1 - set(df1.columns)}"
+        )
+    if not required_cols_2.issubset(df2.columns):
+        raise ValueError(
+            f"df2 is missing required columns: {required_cols_2 - set(df2.columns)}"
+        )
+
+    # Convert to list of tuples for vectorized operations
+    coords1 = df1[[lat_col1, long_col1]].apply(tuple, axis=1).tolist()
+    coords2 = df2[[lat_col2, long_col2]].apply(tuple, axis=1).tolist()
+
+    # Calculate all pairwise distances
     distances = []
+    for i, coord1 in enumerate(coords1):
+        for j, coord2 in enumerate(coords2):
+            try:
+                distance_km = geodesic(coord1, coord2).kilometers
+                distances.append(
+                    {
+                        **df1.iloc[i].to_dict(),
+                        **{f"{col}_Dataset2": df2.iloc[j][col] for col in df2.columns},
+                        "Distance_km": distance_km,
+                    }
+                )
+            except ValueError as e:
+                warnings.warn(
+                    f"Skipping invalid coordinates: {coord1} or {coord2}: {e}"
+                )
+                continue
 
-    for _, row1 in df1.iterrows():
-        for _, row2 in df2.iterrows():
-            coord1 = (row1[lat_col1], row1[long_col1])
-            coord2 = (row2[lat_col2], row2[long_col2])
-            distance_km = geodesic(coord1, coord2).kilometers  # Compute distance
-
-            # Combine all original columns + distance
-            combined_row = {
-                **row1.to_dict(),  # Keep all columns from Dataset1
-                **{
-                    f"{col}_Dataset2": row2[col] for col in df2.columns
-                },  # Keep all columns from Dataset2
-                "Distance_km": distance_km,
-            }
-            distances.append(combined_row)
+    if not distances:
+        raise ValueError("No valid coordinate pairs were processed")
 
     df_distances = pd.DataFrame(distances)
 
-    # Find the closest point for each Point1
-    df_closest: pd.DataFrame = df_distances.loc[
+    # Find closest matches
+    df_closest = df_distances.loc[
         df_distances.groupby(code_col1)["Distance_km"].idxmin()
     ]
 
-    return df_distances, df_closest
+    # Filter by minimum distance
+    df_closest_min_distance = df_distances[df_distances["Distance_km"] < min_distance]
+
+    return df_distances, df_closest, df_closest_min_distance