Update app.py

app.py

@@ -1,15 +1,760 @@
 import streamlit as st
+import pandas as pd
+import plotly.express as px
+import altair as alt
+import folium
+from streamlit_plotly_events import plotly_events # added for part3 interactivity
+from folium.plugins import HeatMap, MarkerCluster
+from streamlit_folium import st_folium
 
-st.title("My First Streamlit App")
+# To fix the color scheme in crash stats plot (asked ChatGPT for appropriate colors)
+severity_colors = {
+    "No Injury": "#1f77b4",
+    "Possible Injury": "#aec7e8",
+    "Non Incapacitating Injury": "#ff7f0e",
+    "Incapacitating Injury": "#ffbb78",
+    "Suspected Minor Injury": "#2ca02c",
+    "Suspected Serious Injury": "#98df8a",
+    "Fatal": "#d62728",
+}
 
-st.write("Hello, Streamlit!")
+@st.cache_data
+def load_and_preprocess_data(file_path):
+    # Read the data
+    df = pd.read_csv(file_path)
+    
+    # Basic preprocessing
+    df = df.drop(['X', 'Y'], axis=1)
+    df.dropna(subset=['Incidentid', 'DateTime', 'Year', 'Latitude', 'Longitude'], inplace=True)
 
-name = st.text_input("Enter your name:")
-if name:
-    st.write("Hello,", name)
+    # Convert Year to int 
+    df['Year'] = df['Year'].astype(int)
 
-#     # /Users/nirmal/Library/Python/3.9/lib/python/site-packages
-# # export PATH="/Users/nirmal/Library/Python/3.9/lib/python/site-packages:$PATHcd
+    # Fill missing values
+    numeric = ['Age_Drv1', 'Age_Drv2']
+    for col in numeric:
+        df[col].fillna(df[col].median(), inplace=True)
+        
+    categorical = ['Gender_Drv1', 'Violation1_Drv1', 'AlcoholUse_Drv1', 'DrugUse_Drv1',
+                  'Gender_Drv2', 'Violation1_Drv2', 'AlcoholUse_Drv2', 'DrugUse_Drv2',
+                  'Unittype_Two', 'Traveldirection_Two', 'Unitaction_Two', 'CrossStreet']
+    for col in categorical:
+        df[col].fillna('Unknown', inplace=True)
+    
+    # Remove invalid ages
+    df = df[
+        (df['Age_Drv1'] <= 90) & 
+        (df['Age_Drv2'] <= 90) & 
+        (df['Age_Drv1'] >= 16) & 
+        (df['Age_Drv2'] >= 16)
+    ]
+    
+    # Create age groups
+    bins = [15, 25, 35, 45, 55, 65, 90]
+    labels = ['16-25', '26-35', '36-45', '46-55', '56-65', '65+']
+    
+    df['Age_Group_Drv1'] = pd.cut(df['Age_Drv1'], bins=bins, labels=labels)
+    df['Age_Group_Drv2'] = pd.cut(df['Age_Drv2'], bins=bins, labels=labels)
+    
+    return df
 
+def create_severity_violation_chart(df, age_group=None):
+    # Apply age group filter if selected
+    if age_group != 'All Ages':
+        df = df[(df['Age_Group_Drv1'] == age_group) | (df['Age_Group_Drv2'] == age_group)]
+    
+    # Combine violations from both drivers
+    violations_1 = df.groupby(['Violation1_Drv1', 'Injuryseverity']).size().reset_index(name='count')
+    violations_2 = df.groupby(['Violation1_Drv2', 'Injuryseverity']).size().reset_index(name='count')
+    
+    violations_1.columns = ['Violation', 'Severity', 'count']
+    violations_2.columns = ['Violation', 'Severity', 'count']
+    
+    violations = pd.concat([violations_1, violations_2])
+    violations = violations.groupby(['Violation', 'Severity'])['count'].sum().reset_index()
+    
+    # Create visualization
+    fig = px.bar(
+        violations,
+        x='Violation',
+        y='count',
+        color='Severity',
+        title=f'Crash Severity Distribution by Violation Type - {age_group}',
+        labels={'count': 'Number of Incidents', 'Violation': 'Violation Type'},
+        height=600,
+        color_discrete_map=severity_colors, # --> for part 3
+    )
+    
+    # fig.update_layout(
+    #     xaxis_tickangle=-45,
+    #     legend_title='Severity Level',
+    #     barmode='stack'
+    # )
 
-# print("hi")
+    # modified the above code because x-axis labels were partially pruned
+    fig.update_layout(
+        xaxis_tickangle=-45,
+        legend_title='Severity Level',
+        barmode='stack',
+        margin=dict(t=50, b=150),  # Increase bottom margin to avoid pruning
+        xaxis=dict(automargin=True)
+    )
+    
+    # return fig
+    return fig, violations
+
+def get_top_violations(df, age_group):
+    # Calculate total incidents for the age group
+    if age_group == 'All Ages':
+        total_incidents = len(df)  
+        # Get violations for all ages
+        violations = pd.concat([
+            df['Violation1_Drv1'].value_counts(),
+            df['Violation1_Drv2'].value_counts()
+        ]).groupby(level=0).sum()
+    else:
+        # Filter for specific age group
+        filtered_df = df[
+            (df['Age_Group_Drv1'] == age_group) | 
+            (df['Age_Group_Drv2'] == age_group)
+        ]
+        total_incidents = len(filtered_df)  
+        # Get violations for specific age group
+        violations = pd.concat([
+            filtered_df['Violation1_Drv1'].value_counts(),
+            filtered_df['Violation1_Drv2'].value_counts()
+        ]).groupby(level=0).sum()
+    
+    # Convert to DataFrame and format
+    violations_df = violations.reset_index()
+    violations_df.columns = ['Violation Type', 'Count']
+    
+    # Sort by Count in descending order
+    violations_df = violations_df.sort_values('Count', ascending=False)
+    
+    # Calculate percentage of total incidents
+    violations_df['Percentage'] = (violations_df['Count'] / total_incidents * 100).round(2)
+    violations_df['Percentage'] = violations_df['Percentage'].map('{:.2f}%'.format)
+    
+    return violations_df.head()
+
+@st.cache_data
+def create_interactive_pie_chart(violations, selected_violation, selected_age):
+    # Filter data based on selected violation
+    filtered_data = violations[violations['Violation'] == selected_violation]
+    
+    # Create a pie chart for severity distribution of the selected violation type
+    fig = px.pie(
+        filtered_data,
+        names='Severity',
+        values='count',
+        # title=f'Severity Level Distribution for Violation: {selected_violation}',
+        title=f'Severity Level Distribution for Violation: {selected_violation} - {selected_age}', # dynamically update pie chart's title
+        height=600,
+        color_discrete_map=severity_colors
+    )
+    
+    return fig
+
+def create_map_bar_chart(df, selected_year):
+    # Create severity count bar chart
+    filtered_df = df[df['Year'] == selected_year]
+    severity_count = filtered_df['Injuryseverity'].value_counts().reset_index()
+    severity_count.columns = ['Injuryseverity', 'Count']
+    
+    fig = px.bar(
+        severity_count, 
+        x='Injuryseverity', 
+        y='Count', 
+        title="Accidents by Severity",
+        labels={'Injuryseverity': 'Severity', 'Count': 'Number of Accidents'}  # Adjust height as needed
+    )
+    fig.update_traces(marker_color='blue')
+    fig.update_layout(
+        clickmode='event+select',  # Enable interactivity
+        xaxis_tickangle=45,       # Rotate x-axis labels 45 degrees
+        margin=dict(t=50, b=150),         # Add bottom margin to prevent label cutoff
+    )
+    return fig
+
+
+@st.cache_data
+def create_map(df, selected_year, selected_severity=None):
+    # Filter data by selected year
+    filtered_df = df[df['Year'] == selected_year]
+    
+    # Filter further by selected severity if provided
+    if selected_severity:
+        filtered_df = filtered_df[filtered_df['Injuryseverity'] == selected_severity]
+    
+    # Remove rows with missing latitude or longitude
+    filtered_df = filtered_df.dropna(subset=['Latitude', 'Longitude'])
+    
+    # Create the map
+    m = folium.Map(
+        location=[33.4255, -111.9400],  # Default location (can be customized)
+        zoom_start=12,
+        control_scale=True,
+        tiles='CartoDB positron'
+    )
+    
+    # Add marker cluster
+    marker_cluster = MarkerCluster(name="Accident Locations").add_to(m)
+    
+    # Add accident markers
+    for _, row in filtered_df.iterrows():
+        folium.Marker(
+            location=[row['Latitude'], row['Longitude']],
+            popup=f"Accident at {row['Longitude']}, {row['Latitude']}<br>Date: {row['DateTime']}<br>Severity: {row['Injuryseverity']}",
+            icon=folium.Icon(color='red')
+        ).add_to(marker_cluster)
+    
+    # Add heatmap
+    heat_data = filtered_df[['Latitude', 'Longitude']].values.tolist()
+    HeatMap(heat_data, radius=15, max_zoom=13, min_opacity=0.3, name="Heat Map").add_to(m)
+    
+    folium.LayerControl().add_to(m)
+    return m
+
+def create_injuries_fatalities_chart(crash_data, unit_type):
+
+    # 5th visualization title
+    # st.header("5. Total Injuries and Fatalities by Month")
+    
+    # Filter rows where we have valid data for all necessary columns
+    crash_data = crash_data[['DateTime', 'Totalinjuries', 'Totalfatalities', 'Unittype_One', 'Unittype_Two']].dropna()
+
+    # Convert "DateTime" to datetime type
+    crash_data['DateTime'] = pd.to_datetime(crash_data['DateTime'], errors='coerce')
+    crash_data['Month'] = crash_data['DateTime'].dt.month_name()
+
+    # sort months in order
+    month_order = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+    crash_data['Month'] = pd.Categorical(crash_data['Month'], categories=month_order, ordered=True)
+
+    # Dropdown for Unit Type selection
+    # Dropdown for Unit Type selection
+    # st.sidebar.selectbox("Select Unit Type", options=['Total'] + crash_data['Unittype_One'].dropna().unique().tolist())  # previous location of dropdown in sidebar
+    # unit_type = st.selectbox("Select Unit Type", options=['Total'] + crash_data['Unittype_One'].dropna().unique().tolist())
+    # unit_type_pairs = set()
+    # for _, row in crash_data[['Unittype_One', 'Unittype_Two']].dropna().iterrows():
+    #     if row['Unittype_One'] != 'Driverless' or row['Unittype_Two'] != 'Driverless':
+    #         pair = ' vs '.join(sorted([row['Unittype_One'], row['Unittype_Two']]))
+    #         unit_type_pairs.add(pair)
+    # # unit_type_pairs = list(unit_type_pairs) # modified as below to sort the dropdown options in alphabetical order
+    # unit_type_pairs = sorted(list(unit_type_pairs))
+    # unit_type = st.selectbox("Select Unit Type Pair", options=['Total'] + unit_type_pairs)
+
+    # Filter data based on the selected unit type
+    if unit_type == 'Total':
+        filtered_data = crash_data
+    else:
+        unit_one, unit_two = unit_type.split(' vs ')
+        filtered_data = crash_data[((crash_data['Unittype_One'] == unit_one) & (crash_data['Unittype_Two'] == unit_two)) |
+                                   ((crash_data['Unittype_One'] == unit_two) & (crash_data['Unittype_Two'] == unit_one))]
+
+    # Group data by month and calculate total injuries and fatalities
+    monthly_sum = filtered_data.groupby('Month').agg({'Totalinjuries': 'sum', 'Totalfatalities': 'sum'}).reset_index()
+
+    # Reshape the data for easier plotting
+    injuries = monthly_sum[['Month', 'Totalinjuries']].rename(columns={'Totalinjuries': 'Value'})
+    injuries['Measure'] = 'Total Injuries'
+
+    fatalities = monthly_sum[['Month', 'Totalfatalities']].rename(columns={'Totalfatalities': 'Value'})
+    fatalities['Measure'] = 'Total Fatalities'
+
+    combined_data = pd.concat([injuries, fatalities])
+
+    # Originally tried to use bar chart but switched to line chart for better trend visualization
+    # alt.Chart(monthly_sum).mark_bar().encode(
+    #     x=alt.X('Month', sort=month_order, title='Month'),
+    #     y=alt.Y('Totalinjuries', title='Total Injuries', axis=alt.Axis(titleColor='blue', labelColor='blue', tickColor='blue')),
+    #     color=alt.value('blue'),
+    #     tooltip=['Month', 'Totalinjuries']
+    # ).properties(
+    #     title='Total Injuries and Fatalities by Month',
+    #     width=300,
+    #     height=300
+    # ) + alt.Chart(monthly_sum).mark_bar().encode(
+    #     x=alt.X('Month', sort=month_order, title='Month'),
+    #     y=alt.Y('Totalfatalities', title='Total Fatalities', axis=alt.Axis(titleColor='red', labelColor='red', tickColor='red')),
+    #     color=alt.value('red'),
+    #     tooltip=['Month', 'Totalfatalities']
+    # )
+
+    # Tried to figure out how to plot a legend using altair
+    # line_chart = alt.Chart(monthly_sum).mark_line(point=True).encode(
+    #     x=alt.X('Month', sort=month_order, title='Month'),
+    #     y=alt.Y('Totalinjuries', title='Total Injuries & Fatalities', axis=alt.Axis(titleColor='black')),
+    #     color=alt.value('blue'),
+    #     tooltip=['Month', 'Totalinjuries']
+    # ).properties(
+    #     title=f'Total Injuries and Fatalities by Month for Unit Type Pair: {unit_type}',
+    #     width=600,
+    #     height=400
+    # ) + alt.Chart(monthly_sum).mark_line(point=True).encode(
+    #     x=alt.X('Month', sort=month_order, title='Month'),
+    #     y=alt.Y('Totalfatalities', axis=alt.Axis(titleColor='red')),
+    #     color=alt.value('red'),
+    #     tooltip=['Month', 'Totalfatalities']
+    # ).configure_legend(
+    #     titleFontSize=14,
+    #     labelFontSize=12,
+    #     titleColor='black',
+    #     labelColor='black'
+    # )
+    
+    # Plot line chart
+    line_chart = alt.Chart(combined_data).mark_line(point=True).encode(
+        x=alt.X('Month:N', sort=month_order, title='Month'),
+        y=alt.Y('Value:Q', title='Total Injuries & Fatalities'),
+        color=alt.Color('Measure:N', title='', scale=alt.Scale(domain=['Total Injuries', 'Total Fatalities'], range=['blue', 'red'])),
+        tooltip=['Month', 'Measure:N', 'Value:Q']
+    ).properties(
+        title=f'Total Injuries and Fatalities by Month for Unit Type Pair: {unit_type}',
+        width=600,
+        height=400
+    )
+
+    # # Combine the charts (trying to make legend)
+    # combined_chart = alt.layer(line_chart_injuries, line_chart_fatalities).properties(
+    #     title=f'Total Injuries and Fatalities by Month for Unit Type Pair: {unit_type}',
+    #     width=600,
+    #     height=400
+    # ).configure_legend(
+    #     titleFontSize=14,
+    #     labelFontSize=12,
+    #     titleColor='black',
+    #     labelColor='black'
+    # )
+    
+    return line_chart
+
+def create_crash_trend_chart(df, weather=None):
+    if weather and weather != 'All Conditions':
+        df = df[df['Weather'] == weather]
+    
+    # Group data by year and count unique Incident IDs
+    trend_data = df.groupby('Year')['Incidentid'].nunique().reset_index()
+    trend_data.columns = ['Year', 'Crash Count']
+    
+    # Create line graph
+    fig = px.line(
+        trend_data,
+        x='Year',
+        y='Crash Count',
+        title=f'Crash Trend Over Time ({weather})',
+        labels={'Year': 'Year', 'Crash Count': 'Number of Unique Crashes'},
+        markers=True,
+        height=600
+    )
+    
+    fig.update_traces(line=dict(width=2), marker=dict(size=8))
+    fig.update_layout(legend_title_text='Trend')
+    
+    return fig
+
+def create_category_distribution_chart(df, selected_category, selected_year):
+    # Filter by selected year
+    if selected_year != 'All Years':
+        df = df[df['Year'] == int(selected_year)]
+
+    # Group by selected category and Injury Severity
+    grouped_data = df.groupby([selected_category, 'Injuryseverity']).size().reset_index(name='Count')
+
+    # Calculate percentages for each category value
+    total_counts = grouped_data.groupby(selected_category)['Count'].transform('sum')
+    grouped_data['Percentage'] = (grouped_data['Count'] / total_counts * 100).round(2)
+
+    # Create the stacked bar chart using Plotly
+    fig = px.bar(
+        grouped_data,
+        x=selected_category,
+        y='Count',
+        color='Injuryseverity',
+        text='Percentage',
+        title=f'Distribution of Incidents by {selected_category} ({selected_year})',
+        labels={'Count': 'Number of Incidents', selected_category: 'Category'},
+        height=600,
+    )
+
+    # Customize the chart appearance
+    fig.update_traces(texttemplate='%{text}%', textposition='inside')
+    fig.update_layout(
+        barmode='stack',
+        xaxis_tickangle=-45,
+        legend_title='Injury Severity',
+        margin=dict(t=50, b=150, l=50, r=50), 
+    )
+
+    return fig
+
+def main():
+    st.set_page_config(page_title="Terrific Tempe Traffic", layout="wide")
+
+    st.markdown("""
+    <style>
+    .reportview-container {
+        font-size: 20px;
+    }
+    h1, h2, h3, h4, h5, h6 {
+        font-size: 150%; 
+    }
+    p {
+        font-size: 125%; 
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+
+    st.markdown("""
+        <style>
+        .title {
+            text-align: center;
+            padding: 25px;
+        }
+        </style>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("<div class='title'><h1> Accident Analysis for City of Tempe,Arizona </h1></div>", unsafe_allow_html=True)
+    
+
+    st.markdown("""
+     **Team Members:**
+    - Janhavi Tushar Zarapkar ([email protected])
+    - Hangyue Zhang ([email protected])
+    - Andrew Nam ([email protected])
+    - Nirmal Attarde ([email protected])
+    - Maanas Sandeep Agrawal ([email protected])
+    """)
+    
+
+    st.markdown("""
+    # Introduction to the Traffic Accident Dataset
+    This dataset contains detailed information about traffic accidents in the city of **Tempe**. It includes various attributes of the accidents, such as the severity of injuries, the demographics of the drivers involved, the locations of the incidents, and the conditions at the time of the accidents. The dataset covers accidents that occurred over several years, with data on factors like **weather conditions**, **road surface conditions**, the **time of day**, and the type of **violations** (e.g., alcohol or drug use) that may have contributed to the accident.
+    
+    The data was sourced from **Tempe City's traffic incident reports** and provides a comprehensive view of the factors influencing road safety and accident severity in the city. By analyzing this dataset, we can gain insights into the key contributors to traffic incidents and uncover trends that could help improve traffic safety measures, urban planning, and law enforcement policies in the city.
+    """)
+    
+    
+    
+    # Load data
+    df = load_and_preprocess_data('1.08_Crash_Data_Report_(detail).csv')
+
+    if 'Weather' not in df.columns:
+        df['Weather'] = 'Unknown'
+
+    if 'selected_violation' not in st.session_state:
+        st.session_state['selected_violation'] = None
+    
+    if "selected_severity" not in st.session_state:
+        st.session_state["selected_severity"] = None
+    
+
+    # Create tabs for different visualizations
+    tab1, tab2, tab3, tab4, tab5 = st.tabs([
+    "Crash Trend", 
+    "Violation-Severity Analysis", 
+    "Distribution by Category",
+    "Crash Injuries/Fatalities",
+    "Severity-Location Analysis"
+])
+    
+    with tab1:
+        # Weather condition filter
+        weather = ['All Conditions'] + sorted(df['Weather'].unique())
+        selected_weather = st.selectbox('Select Weather Condition:', weather)
+        
+        trend_col, desc_col = st.columns([7, 3])
+        
+        with trend_col:
+            trend_fig = create_crash_trend_chart(df, selected_weather)
+            trend_fig.update_layout(
+                height=800,
+                width=None,
+                margin=dict(l=50, r=50, t=50, b=50)
+            )
+            st.plotly_chart(trend_fig, use_container_width=True)
+            
+        
+
+        with desc_col:
+            st.markdown("""
+            ## **Crash Trend Over Time**
+            This interactive line chart visualizes the trend of unique traffic crashes over the years, optionally filtered by weather conditions. It highlights how crash frequency changes over time, helping identify trends and potential contributing factors.
+            
+            **Key Features:**
+            * **Time Trend Analysis**: Displays the total number of unique crashes for each year, showing long-term patterns.
+            * **Weather Filter**: Users can filter the data by weather conditions (e.g., "Rainy", "Sunny") to analyze how weather impacts crash trends.
+            * **Interactive Tooltips**: Hovering over data points reveals the exact crash count for each year, providing detailed insights.
+            
+            **Color Scheme and Design:**
+            * **Line and Markers**: A smooth line connects data points, with prominent markers for each year to highlight trends clearly.
+            * **Dynamic Title**: The chart updates its title to reflect the selected weather condition or "All Conditions" for the overall trend.
+            
+            **Insights:**
+            
+            This chart helps uncover:
+               * Annual fluctuations in crash incidents.
+               * Correlations between weather conditions and crash frequencies.
+               * Historical patterns that can guide future safety measures and urban planning decisions
+            """)
+
+    with tab2:
+        
+        age_groups = ['All Ages', '16-25', '26-35', '36-45', '46-55', '56-65', '65+']
+        selected_age = st.selectbox('Select Age Group:', age_groups)
+
+        trend_col, desc_col = st.columns([6, 4])
+        
+        with trend_col:
+            # Create and display main chart
+            fig, violations = create_severity_violation_chart(df, selected_age)
+            
+            # Display the chart with selection events enabled
+            chart_event = st.plotly_chart(
+                fig, 
+                use_container_width=True,
+                key="violation_chart",
+                on_select="rerun"
+            )
+
+            # Check if there's a selection event
+            if chart_event and chart_event.selection and chart_event.selection.points:
+                # Get the selected violation type
+                selected_violation = chart_event.selection.points[0]['x']
+                # Create and display pie chart for selected violation
+                pie_chart = create_interactive_pie_chart(violations, selected_violation, selected_age)
+                st.plotly_chart(pie_chart, use_container_width=True)
+            
+            # # Display statistics
+            # if selected_age == 'All Ages':
+            #     total_incidents = len(df)
+            # else:
+            #     total_incidents = len(df[
+            #         (df['Age_Group_Drv1'] == selected_age) | 
+            #         (df['Age_Group_Drv2'] == selected_age)
+            #     ])
+
+        with desc_col: 
+            
+            st.markdown("""
+            # Severity of Violations Across Age Groups
+    
+            This section provides an interactive visualization of **crash severities** linked to specific violation types, segmented by driver age groups. It enables a comprehensive analysis of how **age influences crash severity and violation trends**. The visualization is linked to an **interactive pie chart** that updates when a specific bar is selected, displaying the detailed distribution of the selected violation type based on the selected age group.
+    
+            ---
+    
+            ## **Key Features**
+    
+            ### 1. **Age Group Analysis**
+            - Select specific age groups (e.g., "16-25", "65+") or analyze all ages to explore correlations between:
+            - Age
+            - Violation type
+            - Crash severity
+            - Understand how different age groups are involved in various types of violations.
+    
+            ### 2. **Violation Breakdown**
+            - Examine the most frequent violations contributing to traffic accidents for each age group.
+            - View detailed statistics showing the distribution of violation types.
+    
+            ### 3. **Understanding Severity Level**
+            - Identify the proportion of severity levels for a specific violation type based on different age groups.
+            - Investigate detailed severity patterns for each violation type across age groups.
+    
+            ---
+    
+            ## **Insights**
+    
+            - **Identifies High-Risk Behaviors:** 
+            - Highlights risky behaviors such as reckless driving in younger drivers or impaired driving in older groups.
+            
+            - **Highlights Severity Associations:** 
+            - Shows which violations are associated with more severe outcomes, aiding targeted safety interventions and public awareness campaigns.
+    
+            - **Supports Data-Driven Decision Making:** 
+            - Provides insights for designing **age-specific traffic safety programs**.
+    
+            ---
+            """)
+
+    with tab3:
+        # Dropdown for category selection
+        categories = [
+            'Collisionmanner',
+            'Lightcondition',
+            'Weather',
+            'SurfaceCondition',
+            'AlcoholUse_Drv1',
+            'Gender_Drv1',
+        ]
+        selected_category = st.selectbox("Select Category:", categories)
+
+        # Dropdown for year selection
+        years = ['All Years'] + sorted(df['Year'].dropna().unique().astype(int).tolist())
+        selected_year = st.selectbox("Select Year:", years)
+
+        chart_col, desc_col = st.columns([7, 3])
+        
+        with chart_col:
+            distribution_chart = create_category_distribution_chart(df, selected_category, selected_year)
+            distribution_chart.update_layout(
+                height=800,
+                width=None,
+                margin=dict(l=50, r=50, t=50, b=50)
+            )
+            st.plotly_chart(distribution_chart, use_container_width=True)
+
+        with desc_col:
+            st.markdown(f"""
+            ## Distribution of Incidents by {selected_category}
+            This visualization explores the distribution of traffic incidents across various categories, such as Collision Manner, Weather, Surface Condition, Alcohol Use, and Driver Gender. Each bar represents a specific category value (e.g., "Male" or "Female" for Gender), and the bars are divided into segments based on Injury Severity (e.g., Minor, Moderate, Serious, Fatal).
+    
+            **Key Features:**
+            * Interactive Filters: Select a category and filter by year to analyze trends over time.
+            * Insightful Tooltips: Hover over each segment to view the exact count and percentage of incidents for a given severity level.
+            * Comparative Analysis: Quickly identify how different conditions or behaviors correlate with injury severity.
+    
+            This chart provides actionable insights into factors contributing to traffic incidents and their outcomes, helping stakeholders target interventions and improve road safety.
+            """)
+
+    with tab4:
+        # Dropdown for Unit Type selection
+        unit_type_pairs = set()
+        for _, row in df[['Unittype_One', 'Unittype_Two']].dropna().iterrows():
+            if row['Unittype_One'] != 'Driverless' or row['Unittype_Two'] != 'Driverless':
+                pair = ' vs '.join(sorted([row['Unittype_One'], row['Unittype_Two']]))
+                unit_type_pairs.add(pair)
+        unit_type_pairs = sorted(list(unit_type_pairs))
+        unit_type = st.selectbox("Select Unit Type Pair", options=['Total'] + unit_type_pairs)
+    
+        chart_col, desc_col = st.columns([7, 3])
+    
+        with chart_col:
+            injuries_fatalities_chart = create_injuries_fatalities_chart(df, unit_type)
+            injuries_fatalities_chart = injuries_fatalities_chart.properties(
+                height=800
+            )
+            st.altair_chart(injuries_fatalities_chart, use_container_width=True)
+    
+        with desc_col:
+            st.markdown("""
+            ## Injuries and Fatalities Trends
+            
+            This line chart shows the **total number of injuries and fatalities by month for the selected unit type pair**. The visualization helps identify seasonal patterns and critical trends in traffic incidents involving specific unit types.
+    
+            **Key Features:**
+            * **Injuries Trend** (Blue Line)
+                - Tracks monthly injury counts
+                - Shows seasonal variations
+                - Identifies peak incident periods
+    
+            * **Fatalities Trend** (Red Line)
+                - Monitors monthly fatality counts
+                - Generally lower than injuries
+                - Highlights critical safety concerns
+    
+            * **Interactive Selection**
+                - Filter by specific unit type pairs
+                - Compare different vehicle combinations
+                - View overall trends across all types
+    
+            **Applications:**
+            - Identify high-risk months
+            - Guide seasonal safety measures
+            - Inform emergency response planning
+            - Support targeted intervention strategies
+            
+            This visualization aids stakeholders in developing effective safety measures and resource allocation strategies throughout the year.
+            """)
+    
+    with tab5:
+        years = sorted(df['Year'].unique())
+        selected_year = st.selectbox('Select Year:', years)
+        
+        # Create two columns for visualization and description
+        viz_col, desc_col = st.columns([6, 4])
+        
+        with viz_col:
+            # First add bar chart
+            st.subheader("Severity-Location Analysis")
+            bar_fig = create_map_bar_chart(df, selected_year)
+            
+            # Capture click events with bar chart
+            clicked_points = plotly_events(
+                bar_fig, 
+                click_event=True,
+                override_height=300,
+                override_width="100%"
+            )
+            
+            if clicked_points:
+                selected_severity = clicked_points[0]['x']
+                st.session_state["selected_severity"] = selected_severity
+                
+            # Show currently selected severity
+            st.write(f"Selected Severity: {st.session_state['selected_severity'] if st.session_state['selected_severity'] else 'All'}")
+            
+            # Add map below bar chart
+            st.subheader("Accident Locations")
+            map_placeholder = st.empty()
+            with map_placeholder:
+                m = create_map(df, selected_year, st.session_state["selected_severity"])
+                map_data = st_folium(
+                    m,
+                    width=None,
+                    height=600,  # Reduced height since it's now below bar chart
+                    key=f"map_{selected_year}_{st.session_state['selected_severity']}",
+                    returned_objects=["null_drawing"]
+                )
+        
+        with desc_col:
+            st.markdown("""
+            # Exploring Traffic Accident Severity and Location 
+            The two linked graphs show an interactive platform for exploring traffic accident data, featuring a **bar chart** and a **dynamic map**. 
+            - The **bar chart** displays the distribution of accidents by severity.
+            - The **map** combines marker clustering and heatmaps to highlight accident locations. 
+            - Users can filter data by year and severity to explore patterns.
+            ---
+            ## **Key Features**
+            - **Interactive Bar Chart:** 
+            Displays accident counts by severity, updating the map based on selected severity.
+            - **Map with Dual Layers:**
+            Includes marker clustering for individual accidents and a heatmap to visualize accident density.
+            - **Year-Based Filtering:**
+            Allows users to filter data by year and severity for focused analysis.
+            - **Seamless Integration:**
+            Combines Streamlit and Folium, with Plotly events linking the visualizations.
+            ---
+            ## **Design**
+            - **Bar Chart:**
+            - Uses a calm blue color for clarity.
+            - **Map:**
+            - Uses **CartoDB tiles** with red markers and heatmaps for visibility.
+            ---
+            ## **Insights**
+            - **Severity Patterns:** 
+            The bar chart reveals accident trends across severity levels.
+            - **Spatial Trends:** 
+            The map identifies high-risk accident hotspots.
+            - **Yearly and Severity Insights:** 
+            Filters help uncover temporal and severity-related patterns, aiding traffic safety analysis.
+            """)
+    st.markdown("---")
+    
+    # Add conclusion section
+    st.markdown("# Summary and Conclusion")
+    
+    st.markdown("""
+
+This project analyzed traffic accident data for Tempe, Arizona, using interactive visualizations to uncover critical trends and patterns. Key visualizations included crash trends over time, severity analysis by age and violations, injury and fatality trends, and the distribution of incidents across factors like weather and collision manner.
+
+A highlight was the integration of linked visualizations, such as bar charts and dynamic maps, enabling users to explore data interactively. This linkage allowed for seamless filtering and focused analysis of severity and location patterns, making it easier to identify high-risk areas and contributing factors.
+
+These insights are invaluable for city planners, traffic authorities, and safety advocates, helping them design targeted interventions, allocate resources effectively, and improve overall road safety in Tempe.
+    """)
+
+
+
+if __name__ == "__main__":
+    main()