pip install pandas lightningchart

import pandas as pd

# Load the datasets
data_2000_2023 = pd.read_csv('Japan_2000_2023.csv')
data_2001_2018 = pd.read_csv('Japan_2001-2018.csv')

# Convert the 'time' column to datetime format
data_japan_2001_2018['time'] = pd.to_datetime(data_japan_2001_2018['time'], utc=True)
data_japan_2000_2023['time'] = pd.to_datetime(data_japan_2000_2023['time'], utc=True)

# Filter and combine the datasets
data_japan_old_filtered = data_japan_2001_2018[data_japan_2001_2018['time'] < '2019-01-01']
data_japan_new_filtered = data_japan_2000_2023[data_japan_2000_2023['time'] >= '2000-01-01']
combined_data = pd.concat([data_japan_old_filtered, data_japan_new_filtered])

# Remove duplicates based on the 'time' column and create a copy to avoid SettingWithCopyWarning
cleaned_combined_data = combined_data.drop_duplicates(subset=['time']).copy()

# Verify that duplicates have been removed
remaining_duplicates = cleaned_combined_data.duplicated(subset=['time']).sum()
remaining_duplicates

# Extract longitude, latitude, depth, and magnitude values from the dataset
x_values = cleaned_combined_data['longitude'].tolist()
y_values = cleaned_combined_data['latitude'].tolist()
z_values = cleaned_combined_data['depth'].tolist()
magnitude_values = cleaned_combined_data['mag'].tolist()  # Magnitude values for coloring

# Normalize the magnitude values to a range between 0 and 1 for color mapping
min_mag = min(magnitude_values)
max_mag = max(magnitude_values)
lookup_values = [(m - min_mag) / (max_mag - min_mag) for m in magnitude_values]

# Create a 3D chart with a dark theme
chart = lc.Chart3D(
    theme=lc.Themes.Dark,
    title='3D Visualization of Seismic Events (Longitude, Latitude, Depth)'
)

# Set titles for the axes
chart.get_default_x_axis().set_title("Longitude")
chart.get_default_y_axis().set_title("Latitude")
chart.get_default_z_axis().set_title("Depth (km)")

# Create a point series with individual controls for size and color enabled
series = chart.add_point_series(
    render_2d=False,  # Ensure the points are rendered in 3D
    individual_lookup_values_enabled=True,
    individual_point_size_axis_enabled=True,
    individual_point_size_enabled=True  # Enable individual point size adjustments
)

# Set the shape of the points to be spherical
series.set_point_shape('sphere')

# Define a color palette for the points based on the normalized magnitude values
series.set_palette_point_colors(
    steps=[
        {'value': 0.0, 'color': lc.Color(0, 0, 255)},     # Blue for the lowest magnitudes
        {'value': 0.25, 'color': lc.Color(0, 255, 0)},    # Green for lower-mid magnitudes
        {'value': 0.5, 'color': lc.Color(255, 255, 0)},   # Yellow for medium magnitudes
        {'value': 0.75, 'color': lc.Color(255, 165, 0)},  # Orange for higher-mid magnitudes
        {'value': 1.0, 'color': lc.Color(255, 0, 0)}      # Red for the highest magnitudes
    ],
    look_up_property='value',  # Use 'value' property (normalized magnitude) for color mapping
    interpolate=True,  # Interpolate colors between the defined steps for smooth transitions
    percentage_values=True  # Interpret 'value' as a percentage of the normalized range (0 to 1)
)

# Prepare the data for the chart
data = [
    {
        'x': x_values[i],  # Longitude
        'y': y_values[i],  # Latitude
        'z': z_values[i],  # Depth
        'size': 7 if magnitude_values[i] > 6.0 else 4,  # Size points larger for magnitudes > 6.0
        'value': lookup_values[i]  # Normalized magnitude value for color lookup
    }
    for i in range(len(x_values))
]

# Add the prepared data to the point series
series.add(data)

# Opens the 3D chart in a web browser window for better interactive viewing
chart.open(method="browser")

# Extract the year from the 'time' column and create a new 'year' column in the DataFrame
cleaned_combined_data['year'] = cleaned_combined_data['time'].dt.year

# Count the number of seismic events per year, sort the counts by year, and store them in a variable
event_counts_per_year = cleaned_combined_data['year'].value_counts().sort_index()

# Convert each year to milliseconds since the Unix epoch (January 1, 1970) for the x-axis values
xValues = [
    int(time.mktime(datetime(year, 1, 1).timetuple()) * 1000) 
    for year in event_counts_per_year.index.tolist()
]

# Get the corresponding event counts as the y-axis values
yValues = event_counts_per_year.values.tolist()

# Create an XY chart with a dark theme and a title
chart = lc.ChartXY(
    theme=lc.Themes.Dark,
    title='Seismic Events Over Time'
)

# Remove the default x-axis to customize it
chart.get_default_x_axis().dispose()

# Add a new high-precision linear x-axis to handle the date values
x_axis = chart.add_x_axis(axis_type='linear-highPrecision')

# Set the tick strategy to 'DateTime' to appropriately format the x-axis labels
x_axis.set_tick_strategy('DateTime')

# Set the scroll strategy to 'progressive' for better visualization of data over time
x_axis.set_scroll_strategy('progressive')

# Set the interval for the x-axis based on the minimum and maximum values of xValues (milliseconds)
x_axis.set_interval(start=min(xValues),
    end=max(xValues),
    stop_axis_after=False  # Keep the axis open-ended to allow further extension
  )

# Set the title for the x-axis
x_axis.set_title("Year")

# Set the title for the y-axis
chart.get_default_y_axis().set_title("Events")

# Add a series to the chart to plot the seismic events, using the x and y values
series = chart.add_point_line_series().append_samples(
    x_values=xValues,
    y_values=yValues
)

# Set the color of the points in the series to bright red (RGB: 255, 0, 0)
series.set_point_color(lc.Color(255, 0, 0))

# Set the thickness of the line connecting the points to 2 units for better visibility
series.set_line_thickness(2)

# Open the chart
chart.open()

import calendar

# Extract the month from the 'time' column in the DataFrame and create a new 'month' column
cleaned_combined_data['month'] = cleaned_combined_data['time'].dt.month

# Group the data by the 'month' column and count the number of seismic events for each month
monthly_event_counts = cleaned_combined_data.groupby('month').size()

# Create a list of dictionaries where each dictionary represents a month and its corresponding event count
# The 'category' key uses the full month name (e.g., 'January') and 'value' is the event count
data = [{'category': calendar.month_name[month], 'value': count} for month, count in monthly_event_counts.items()]

# Filter the dataset to only include events that occurred in March 2011
march_2011_data = cleaned_combined_data[(cleaned_combined_data['year'] == 2011) & (cleaned_combined_data['month'] == 3)]

# Count the number of seismic events that occurred in March 2011
march_2011_event_count = march_2011_data.shape[0]

# Print the number of seismic events in March 2011
print(f"Number of seismic events in March 2011: {march_2011_event_count}")

# Create a vertical bar chart with a dark theme
chart = lc.BarChart(
    vertical=True,  
    theme=lc.Themes.Dark,
    title='Monthly Frequency of Events in Japan'
)

# Disable sorting to display the months in their natural order (January to December)
chart.set_sorting('disabled')

# Set the chart data using the list of dictionaries, where 'category' is the month name and 'value' is the event count
chart.set_data(data)

chart.open()

# Define the geographic boundaries for different regions in Japan
# Each region is defined by its minimum and maximum latitude and longitude
regions = {
    'Hokkaidō': {'lat_min': 41, 'lat_max': 45.5, 'lon_min': 139, 'lon_max': 146},
    'Tōhoku': {'lat_min': 36.5, 'lat_max': 41.5, 'lon_min': 139, 'lon_max': 142},   
    'Kantō': {'lat_min': 34, 'lat_max': 37, 'lon_min': 138, 'lon_max': 141}, 
    'Chūbu': {'lat_min': 34, 'lat_max': 38.5, 'lon_min': 136, 'lon_max': 139},  
    'Kansai': {'lat_min': 33.5, 'lat_max': 36, 'lon_min': 134, 'lon_max': 137},  
    'Chūgoku': {'lat_min': 33.5, 'lat_max': 36.5, 'lon_min': 130.5, 'lon_max': 134},  
    'Shikoku': {'lat_min': 32.5, 'lat_max': 34.5, 'lon_min': 132, 'lon_max': 135},  
    'Kyūshū & Okinawa': {'lat_min': 23.5, 'lat_max': 34, 'lon_min': 123.5, 'lon_max': 132}, 
    'North East Shore': {'lat_min': 42, 'lat_max': 50, 'lon_min': 145.5, 'lon_max': 155.5},   
    'North West Shore': {'lat_min': 37.5, 'lat_max': 43, 'lon_min': 130, 'lon_max': 139},   
    'East Shore': {'lat_min': 35, 'lat_max': 42, 'lon_min': 141, 'lon_max': 150},   
    'South East Shore': {'lat_min': 20, 'lat_max': 35, 'lon_min': 135, 'lon_max': 150},   
}

# Function to assign a region to each row based on latitude and longitude
def assign_region(row):
    for region, bounds in regions.items():
        # Check if the latitude and longitude of the row fall within the bounds of the region
        if bounds['lat_min'] <= row['latitude'] <= bounds['lat_max'] and bounds['lon_min'] <= row['longitude'] <= bounds['lon_max']:
            return region  # Return the region name if the location matches the bounds
    return 'Other'  # Return 'Other' if no region matches the location

# Apply the function to the DataFrame to assign regions based on latitude and longitude
cleaned_combined_data['region'] = cleaned_combined_data.apply(assign_region, axis=1)

# Group the data by the newly created 'region' column and count the number of seismic events in each region
region_event_counts = cleaned_combined_data.groupby('region').size()

# Create a list of dictionaries with each region's name and the corresponding event count
data = [{'category': region, 'value': count} for region, count in region_event_counts.items()]

# Create a vertical bar chart with a dark theme, titled "Distribution of Seismic Events by Region"
chart = lc.BarChart(
    vertical=True,  # Set the chart orientation to vertical
    theme=lc.Themes.Dark,  # Use a dark theme for the chart
    title='Distribution of Seismic Events by Region'  # Set the title of the chart
)

# Set the sorting of the bars in descending order, so regions with more events are shown first
chart.set_sorting('descending')

# Set the data for the chart using the list of dictionaries, where 'category' is the region name and 'value' is the event count
chart.set_data(data)

chart.open()