Update app.py

app.py

@@ -41,36 +41,84 @@ try:
     
     selected_country = st.selectbox("Choose a country", countries)
     
-    # Load data for selected country only
+    # Load data for selected country and world data
     gdf = gpd.read_file(dataset_path, layer=0, where=f"NAME_0 = '{selected_country}'")
     gdf = gdf[gdf.is_valid].to_crs("EPSG:4326")
-
-    # Initialize dictionary to store selected regions for each level
-    selected_regions = {}
     
+    # Load world data for the third visualization
+    world_gdf = gpd.read_file(dataset_path, layer=0)
+    world_gdf = world_gdf[world_gdf.is_valid].to_crs("EPSG:4326")
+
     # Special handling for Pakistan
     if selected_country == "Pakistan":
         # Define administrative levels for Pakistan
         admin_levels = {
-            "Provinces": ["Punjab", "Sindh", "Khyber Pakhtunkhwa", "Balochistan"],
-            "Territories": ["Islamabad Capital Territory", "Gilgit-Baltistan", "Azad Kashmir"]
+            "Provinces and Territories": "NAME_1",
         }
-        
-        # Add other administrative levels
+        # Add other administrative levels if available
         for i in range(2, 6):
             col_name = f"NAME_{i}"
             if col_name in gdf.columns and not gdf[col_name].isna().all():
-                admin_levels[f"Administrative Level {i}"] = sorted(gdf[col_name].dropna().unique())
+                level_name = f"Administrative Level {i}"
+                admin_levels[level_name] = col_name
 
-        # Create multiselect for each administrative level
-        for level, regions in admin_levels.items():
-            selected = st.multiselect(
-                f"Select {level}",
-                regions,
-                default=regions if level in ["Provinces", "Territories"] else []
-            )
+        # Define Pakistan-specific regions
+        pakistan_regions = {
+            "Provinces": ["Punjab", "Sindh", "Khyber Pakhtunkhwa", "Balochistan"],
+            "Territories": ["Islamabad Capital Territory", "Gilgit-Baltistan", "Azad Kashmir"]
+        }
+
+        # Selection for Pakistan's administrative levels
+        selected_admin_levels = st.multiselect(
+            "Select Administrative Levels to Display",
+            list(admin_levels.keys()),
+            default=["Provinces and Territories"]
+        )
+
+        # Initialize selected_gdf and selected_areas
+        selected_gdf = gpd.GeoDataFrame(columns=gdf.columns, geometry='geometry', crs=gdf.crs)
+        selected_areas = []
+
+        # Handle selection for Pakistan's provinces and territories
+        if "Provinces and Territories" in selected_admin_levels:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                selected_provinces = st.multiselect(
+                    "Select Provinces",
+                    pakistan_regions["Provinces"],
+                    default=pakistan_regions["Provinces"]
+                )
+            
+            with col2:
+                selected_territories = st.multiselect(
+                    "Select Territories",
+                    pakistan_regions["Territories"],
+                    default=pakistan_regions["Territories"]
+                )
+            
+            # Combine provinces and territories selections
+            selected = selected_provinces + selected_territories
             if selected:
-                selected_regions[level] = selected
+                level_gdf = gdf[gdf["NAME_1"].isin(selected)]
+                selected_gdf = pd.concat([selected_gdf, level_gdf], ignore_index=True)
+                selected_areas.extend(selected)
+
+        # Handle other administrative levels
+        for level in selected_admin_levels:
+            if level != "Provinces and Territories":
+                name_column = admin_levels[level]
+                available_areas = sorted(gdf[name_column].dropna().unique())
+                selected = st.multiselect(
+                    f"Select {level} regions",
+                    available_areas,
+                    key=f"select_{level}"
+                )
+                
+                if selected:
+                    level_gdf = gdf[gdf[name_column].isin(selected)]
+                    selected_gdf = pd.concat([selected_gdf, level_gdf], ignore_index=True)
+                    selected_areas.extend(selected)
 
     else:
         # Handle other countries
@@ -79,45 +127,58 @@ try:
             col_name = f"NAME_{i}"
             if col_name in gdf.columns and not gdf[col_name].isna().all():
                 level_name = f"Administrative Level {i}"
-                admin_levels[level_name] = sorted(gdf[col_name].dropna().unique())
+                admin_levels[level_name] = col_name
 
-        # Create multiselect for each administrative level
-        for level, regions in admin_levels.items():
+        # Select administrative levels to display
+        selected_admin_levels = st.multiselect(
+            "Select Administrative Levels to Display",
+            list(admin_levels.keys()),
+            default=[list(admin_levels.keys())[0]] if admin_levels else []
+        )
+
+        # Initialize selected_gdf and selected_areas
+        selected_gdf = gpd.GeoDataFrame(columns=gdf.columns, geometry='geometry', crs=gdf.crs)
+        selected_areas = []
+
+        # Handle selection for each administrative level
+        for level in selected_admin_levels:
+            name_column = admin_levels[level]
+            available_areas = sorted(gdf[name_column].dropna().unique())
             selected = st.multiselect(
                 f"Select {level} regions",
-                regions,
-                default=regions if level == "Administrative Level 1" else []
+                available_areas,
+                key=f"select_{level}"
             )
+            
             if selected:
-                selected_regions[level] = selected
+                level_gdf = gdf[gdf[name_column].isin(selected)]
+                selected_gdf = pd.concat([selected_gdf, level_gdf], ignore_index=True)
+                selected_areas.extend(selected)
 
-    if selected_regions:
+    if not selected_gdf.empty and selected_areas:
         # Area Customization
         st.subheader("🎨 Area Customization")
         
         # Create columns for color pickers
         num_cols = 3
         cols = st.columns(num_cols)
-        colors = {}
+        border_colors = {}
+        fill_colors = {}
         
-        # Create color pickers for each level and its regions
-        col_idx = 0
-        for level, regions in selected_regions.items():
-            with cols[col_idx % num_cols]:
-                st.markdown(f"### {level}")
-                colors[level] = {
-                    "border": st.color_picker(
-                        f"Border color for {level}",
-                        "#000000",
-                        key=f"border_{level}"
-                    ),
-                    "fill": st.color_picker(
-                        f"Fill color for {level}",
-                        f"#{hash(level) % 0xFFFFFF:06x}",
-                        key=f"fill_{level}"
-                    )
-                }
-            col_idx += 1
+        # Create color pickers for each area
+        for idx, area in enumerate(selected_areas):
+            with cols[idx % num_cols]:
+                st.markdown(f"### {area}")
+                border_colors[area] = st.color_picker(
+                    f"Border color for {area}",
+                    "#000000",
+                    key=f"border_{area}"
+                )
+                fill_colors[area] = st.color_picker(
+                    f"Fill color for {area}",
+                    f"#{hash(area) % 0xFFFFFF:06x}",
+                    key=f"fill_{area}"
+                )
 
         # Legend Customization
         st.subheader("📌 Legend Customization")
@@ -142,43 +203,49 @@ try:
         
         def create_2d_map():
             fig, ax = plt.subplots(figsize=(15, 10))
-            patches = []
-            legend_labels = []
 
-            def plot_geometry(geom, level):
-                if isinstance(geom, MultiPolygon):
-                    for poly in geom.geoms:
+            # Plot all regions first with a light gray color
+            for _, row in gdf.iterrows():
+                if isinstance(row.geometry, MultiPolygon):
+                    for poly in row.geometry.geoms:
                         x, y = poly.exterior.xy
-                        ax.fill(x, y, color=colors[level]["fill"], alpha=0.5)
-                        ax.plot(x, y, color=colors[level]["border"], linewidth=1)
-                elif isinstance(geom, Polygon):
-                    x, y = geom.exterior.xy
-                    ax.fill(x, y, color=colors[level]["fill"], alpha=0.5)
-                    ax.plot(x, y, color=colors[level]["border"], linewidth=1)
-
-            # Plot each level
-            for level, regions in selected_regions.items():
-                level_gdf = None
-                
-                if level == "Provinces":
-                    level_gdf = gdf[gdf["NAME_1"].isin(regions)]
-                elif level == "Territories":
-                    level_gdf = gdf[gdf["NAME_1"].isin(regions)]
+                        ax.fill(x, y, color='#EEEEEE', alpha=0.3)
+                        ax.plot(x, y, color='#CCCCCC', linewidth=0.5)
                 else:
-                    col_name = f"NAME_{level.split()[-1]}"
-                    level_gdf = gdf[gdf[col_name].isin(regions)]
-
-                if level_gdf is not None and not level_gdf.empty:
-                    for _, row in level_gdf.iterrows():
-                        plot_geometry(row["geometry"], level)
-                    
-                    if level not in legend_labels:
+                    x, y = row.geometry.exterior.xy
+                    ax.fill(x, y, color='#EEEEEE', alpha=0.3)
+                    ax.plot(x, y, color='#CCCCCC', linewidth=0.5)
+
+            patches = []
+            legend_labels = []
+
+            # Plot selected areas with their chosen colors
+            for _, row in selected_gdf.iterrows():
+                area_name = None
+                for level in selected_admin_levels:
+                    col_name = admin_levels[level]
+                    if row[col_name] in selected_areas:
+                        area_name = row[col_name]
+                        break
+
+                if area_name and area_name in border_colors:
+                    if isinstance(row.geometry, MultiPolygon):
+                        for poly in row.geometry.geoms:
+                            x, y = poly.exterior.xy
+                            ax.fill(x, y, color=fill_colors[area_name], alpha=0.5)
+                            ax.plot(x, y, color=border_colors[area_name], linewidth=1)
+                    else:
+                        x, y = row.geometry.exterior.xy
+                        ax.fill(x, y, color=fill_colors[area_name], alpha=0.5)
+                        ax.plot(x, y, color=border_colors[area_name], linewidth=1)
+
+                    if area_name not in legend_labels:
                         patch = plt.Rectangle((0, 0), 1, 1,
-                                           fc=colors[level]["fill"],
-                                           ec=colors[level]["border"],
+                                           fc=fill_colors[area_name],
+                                           ec=border_colors[area_name],
                                            alpha=0.5)
                         patches.append(patch)
-                        legend_labels.append(level)
+                        legend_labels.append(area_name)
 
             if patches:
                 ax.legend(patches, legend_labels,
@@ -217,8 +284,8 @@ try:
             f"image/{format_option.lower()}"
         )
 
-        # 3D Map Visualization
-        st.subheader("🌐 3D Map Visualization")
+        # 3D Map Visualization (Current Version)
+        st.subheader("🌐 3D Map Visualization (Current Version)")
         
         st.markdown("""
             <style>
@@ -232,78 +299,91 @@ try:
             fig_3d = go.Figure()
             added_to_legend = set()
 
-            def create_3d_trace(geom, level, show_in_legend):
-                traces = []
-                if isinstance(geom, MultiPolygon):
-                    for poly in geom.geoms:
+            # First plot all regions in light gray
+            for _, row in gdf.iterrows():
+                if isinstance(row.geometry, MultiPolygon):
+                    for poly in row.geometry.geoms:
                         x, y = poly.exterior.xy
-                        traces.append(
-                            go.Scatter3d(
+                        fig_3d.add_trace(go.Scatter3d(
+                            x=list(x), y=list(y), z=[0]*len(x),
+                            mode='lines',
+                            line=dict(color='#CCCCCC', width=1),
+                            showlegend=False
+                        ))
+                else:
+                    x, y = row.geometry.exterior.xy
+                    fig_3d.add_trace(go.Scatter3d(
+                        x=list(x), y=list(y), z=[0]*len(x),
+                        mode='lines',
+                        line=dict(color='#CCCCCC', width=1),
+                        showlegend=False
+                    ))
+
+            # Then plot selected areas with their colors
+            for _, row in selected_gdf.iterrows():
+                area_name = None
+                for level in selected_admin_levels:
+                    col_name = admin_levels[level]
+                    if row[col_name] in selected_areas:
+                        area_name = row[col_name]
+                        break
+
+                if area_name and area_name in border_colors:
+                    if isinstance(row.geometry, MultiPolygon):
+                        for poly in row.geometry.geoms:
+                            x, y = poly.exterior.xy
+                            if area_name not in added_to_legend:
+                                fig_3d.add_trace(go.Scatter3d(
+                                    x=list(x), y=list(y), z=[0]*len(x),
+                                    mode='lines+markers',
+                                    line=dict(color=border_colors[area_name], width=2),
+                                    marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                    name=area_name,
+                                    showlegend=True
+                                ))
+                                added_to_legend.add(area_name)
+                            else:
+                                fig_3d.add_trace(go.Scatter3d(
+                                    x=list(x), y=list(y), z=[0]*len(x),
+                                    mode='lines+markers',
+                                    line=dict(color=border_colors[area_name], width=2),
+                                    marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                    name=area_name,
+                                    showlegend=False
+                                ))
+                            fig_3d.add_trace(go.Mesh3d(
+                                x=list(x), y=list(y), z=[0]*len(x),
+                                color=fill_colors[area_name],
+                                opacity=0.3,
+                                showlegend=False
+                            ))
+                    else:
+                        x, y = row.geometry.exterior.xy
+                        if area_name not in added_to_legend:
+                            fig_3d.add_trace(go.Scatter3d(
                                 x=list(x), y=list(y), z=[0]*len(x),
                                 mode='lines+markers',
-                                line=dict(color=colors[level]["border"], width=2),
-                                marker=dict(
-                                    size=1,
-                                    color=colors[level]["fill"],
-                                    opacity=0.5
-                                ),
-                                name=level,
-                                showlegend=show_in_legend and len(traces) == 0
-                            )
-                        )
-                        traces.append(
-                            go.Mesh3d(
+                                line=dict(color=border_colors[area_name], width=2),
+                                marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                name=area_name,
+                                showlegend=True
+                            ))
+                            added_to_legend.add(area_name)
+                        else:
+                            fig_3d.add_trace(go.Scatter3d(
                                 x=list(x), y=list(y), z=[0]*len(x),
-                                color=colors[level]["fill"],
-                                opacity=0.3,
+                                mode='lines+markers',
+                                line=dict(color=border_colors[area_name], width=2),
+                                marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                name=area_name,
                                 showlegend=False
-                            )
-                        )
-                elif isinstance(geom, Polygon):
-                    x, y = geom.exterior.xy
-                    traces.append(
-                        go.Scatter3d(
-                            x=list(x), y=list(y), z=[0]*len(x),
-                            mode='lines+markers',
-                            line=dict(color=colors[level]["border"], width=2),
-                            marker=dict(
-                                size=1,
-                                color=colors[level]["fill"],
-                                opacity=0.5
-                            ),
-                            name=level,
-                            showlegend=show_in_legend
-                        )
-                    )
-                    traces.append(
-                        go.Mesh3d(
+                            ))
+                        fig_3d.add_trace(go.Mesh3d(
                             x=list(x), y=list(y), z=[0]*len(x),
-                            color=colors[level]["fill"],
+                            color=fill_colors[area_name],
                             opacity=0.3,
                             showlegend=False
-                        )
-                    )
-                return traces
-
-            # Plot each level
-            for level, regions in selected_regions.items():
-                level_gdf = None
-                
-                if level == "Provinces":
-                    level_gdf = gdf[gdf["NAME_1"].isin(regions)]
-                elif level == "Territories":
-                    level_gdf = gdf[gdf["NAME_1"].isin(regions)]
-                else:
-                    col_name = f"NAME_{level.split()[-1]}"
-                    level_gdf = gdf[gdf[col_name].isin(regions)]
-
-                if level_gdf is not None and not level_gdf.empty:
-                    for _, row in level_gdf.iterrows():
-                        first_occurrence = level not in added_to_legend
-                        traces = create_3d_trace(row["geometry"], level, first_occurrence)
-                        for trace in traces:
-                            fig_3d.add_trace(trace)
-                        added_to_legend.add(level)
+                        ))
 
             fig_3d.update_layout(
                 scene=dict(
@@ -340,20 +420,165 @@ try:
             )
             return fig_3d
 
-        # Create and display 3D map
+        # Create and display 3D map (Current Version)
         fig_3d = create_3d_map()
         st.plotly_chart(fig_3d, use_container_width=True)
 
-        # Add download button for 3D map
-        if st.button("Download 3D Map (HTML)"):
-            html_buffer = io.StringIO()
-            fig_3d.write_html(html_buffer)
-            st.download_button(
-                label="Click to Download 3D Map",
-                data=html_buffer.getvalue(),
-                file_name=f"{selected_country.lower()}_map_3d.html",
-                mime="text/html"
+        # 3D Map Visualization (World Map Version)
+        st.subheader("🌎 3D Map Visualization (World Map)")
+        
+        def create_3d_world_map():
+            fig_world = go.Figure()
+            added_to_legend = set()
+
+            # Plot all countries in light gray
+            for _, row in world_gdf.iterrows():
+                if isinstance(row.geometry, MultiPolygon):
+                    for poly in row.geometry.geoms:
+                        x, y = poly.exterior.xy
+                        fig_world.add_trace(go.Scatter3d(
+                            x=list(x), y=list(y), z=[0]*len(x),
+                            mode='lines',
+                            line=dict(color='#CCCCCC', width=1),
+                            showlegend=False
+                        ))
+                else:
+                    x, y = row.geometry.exterior.xy
+                    fig_world.add_trace(go.Scatter3d(
+                        x=list(x), y=list(y), z=[0]*len(x),
+                        mode='lines',
+                        line=dict(color='#CCCCCC', width=1),
+                        showlegend=False
+                    ))
+
+            # Plot selected areas with their colors
+            for _, row in selected_gdf.iterrows():
+                area_name = None
+                for level in selected_admin_levels:
+                    col_name = admin_levels[level]
+                    if row[col_name] in selected_areas:
+                        area_name = row[col_name]
+                        break
+
+                if area_name and area_name in border_colors:
+                    if isinstance(row.geometry, MultiPolygon):
+                        for poly in row.geometry.geoms:
+                            x, y = poly.exterior.xy
+                            if area_name not in added_to_legend:
+                                fig_world.add_trace(go.Scatter3d(
+                                    x=list(x), y=list(y), z=[0]*len(x),
+                                    mode='lines+markers',
+                                    line=dict(color=border_colors[area_name], width=2),
+                                    marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                    name=area_name,
+                                    showlegend=True
+                                ))
+                                added_to_legend.add(area_name)
+                            else:
+                                fig_world.add_trace(go.Scatter3d(
+                                    x=list(x), y=list(y), z=[0]*len(x),
+                                    mode='lines+markers',
+                                    line=dict(color=border_colors[area_name], width=2),
+                                    marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                    name=area_name,
+                                    showlegend=False
+                                ))
+                            fig_world.add_trace(go.Mesh3d(
+                                x=list(x), y=list(y), z=[0]*len(x),
+                                color=fill_colors[area_name],
+                                opacity=0.3,
+                                showlegend=False
+                            ))
+                    else:
+                        x, y = row.geometry.exterior.xy
+                        if area_name not in added_to_legend:
+                            fig_world.add_trace(go.Scatter3d(
+                                x=list(x), y=list(y), z=[0]*len(x),
+                                mode='lines+markers',
+                                line=dict(color=border_colors[area_name], width=2),
+                                marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                name=area_name,
+                                showlegend=True
+                            ))
+                            added_to_legend.add(area_name)
+                        else:
+                            fig_world.add_trace(go.Scatter3d(
+                                x=list(x), y=list(y), z=[0]*len(x),
+                                mode='lines+markers',
+                                line=dict(color=border_colors[area_name], width=2),
+                                marker=dict(size=1, color=fill_colors[area_name], opacity=0.5),
+                                name=area_name,
+                                showlegend=False
+                            ))
+                        fig_world.add_trace(go.Mesh3d(
+                            x=list(x), y=list(y), z=[0]*len(x),
+                            color=fill_colors[area_name],
+                            opacity=0.3,
+                            showlegend=False
+                        ))
+
+            fig_world.update_layout(
+                scene=dict(
+                    aspectmode='data',
+                    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                    zaxis=dict(showgrid=False, zeroline=False, showticklabels=False, range=[-1, 1])
+                ),
+                margin=dict(t=30, b=0, l=0, r=0),
+                legend=dict(
+                    font=dict(
+                        size=legend_font_size,
+                        weight=legend_font_weight.lower()
+                    ),
+                    bgcolor=legend_bg_color,
+                    bordercolor=legend_border_color,
+                    borderwidth=legend_border_width,
+                    orientation="h" if legend_columns > 1 else "v",
+                    yanchor="bottom",
+                    y=1.02,
+                    xanchor="right",
+                    x=1,
+                    title=dict(
+                        text=legend_title,
+                        font=dict(
+                            size=legend_font_size + 2
+                        )
+                    ),
+                    itemsizing='constant',
+                    traceorder='normal' if legend_columns == 1 else 'grouped'
+                ),
+                showlegend=True,
+                height=800
             )
+            return fig_world
+
+        # Create and display 3D world map
+        fig_world = create_3d_world_map()
+        st.plotly_chart(fig_world, use_container_width=True)
+
+        # Add download buttons for both 3D maps
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Download 3D Map (Current Version)"):
+                html_buffer = io.StringIO()
+                fig_3d.write_html(html_buffer)
+                st.download_button(
+                    label="Click to Download 3D Map (Current Version)",
+                    data=html_buffer.getvalue(),
+                    file_name=f"{selected_country.lower()}_map_3d.html",
+                    mime="text/html"
+                )
+        
+        with col2:
+            if st.button("Download 3D World Map"):
+                html_buffer = io.StringIO()
+                fig_world.write_html(html_buffer)
+                st.download_button(
+                    label="Click to Download 3D World Map",
+                    data=html_buffer.getvalue(),
+                    file_name=f"{selected_country.lower()}_world_map_3d.html",
+                    mime="text/html"
+                )
 
 except Exception as e:
     st.error(f"⚠️ Error: {e}")