diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..366a44c Binary files /dev/null and b/.DS_Store differ diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..e776d72 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.ipynb linguist-documentation=true \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57bf9b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.ipynb_checkpoints/ +data/TrendFirePy_output.tif +data/inputResampled.tif +.specstory/ +.md +.cursorindexingignore diff --git a/FireVulnerability.py b/FireVulnerability.py new file mode 100644 index 0000000..86f136d --- /dev/null +++ b/FireVulnerability.py @@ -0,0 +1,1448 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" +FireVulnerability.py: Python implementation of FireVulnerability.js using Earth Engine Python API. + +This script maps fire vulnerability based on long-term trends, static factors, +and historical fire data using a Random Forest classifier. + +Steps: +1. Load study area boundary. +2. Load and prepare historical fire points. +3. Load and process auxiliary datasets (NICFI, MODIS LST, DEM, Roads). +4. Calculate trends for NICFI and MODIS LST. +5. Load pre-computed trend layers from TrendFire. +6. Combine all input features into a single multi-band image. +7. Resample the combined feature image to a consistent grid (e.g., 30m EPSG:3857). +8. Prepare training data by sampling features at fire and non-fire locations. +9. Train a Random Forest classifier. +10. Evaluate the classifier. +11. Apply the classifier to the entire study area to create the vulnerability map. +12. Export the final vulnerability map. +""" + +import ee +import os +import datetime +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import geopandas as gpd +from tqdm import tqdm +from sklearn.ensemble import RandomForestClassifier +from sklearn.metrics import accuracy_score, confusion_matrix, classification_report +import seaborn as sns + +# Define the Goa study area boundary +def get_study_boundary(): + """ + Get the study area boundary for Goa, India. + Returns an ee.Geometry. + """ + # Method 1: Load from a shapefile if available locally + try: + boundary_path = os.path.join('data', 'pa_boundary.shp') + if os.path.exists(boundary_path): + boundary_gdf = gpd.read_file(boundary_path) + # Convert to GeoJSON + boundary_geojson = boundary_gdf.geometry.__geo_interface__ + # Create an EE geometry + return ee.Geometry.Polygon(boundary_geojson['features'][0]['geometry']['coordinates']) + except Exception as e: + print(f"Could not load boundary from shapefile: {e}") + + # Method 2: Use predefined feature from Earth Engine + try: + # Get the Goa district boundary from Earth Engine's administrative boundaries + goa = ee.FeatureCollection("FAO/GAUL/2015/level1").filter(ee.Filter.eq('ADM1_NAME', 'Goa')) + return goa.geometry() + except Exception as e: + print(f"Could not load boundary from Earth Engine: {e}") + + # Method 3: Define manually as fallback + # These coordinates would need to be adjusted to match the study area + goa_coords = [ + [73.6765, 15.7560], + [74.3161, 15.7560], + [74.3161, 14.8922], + [73.6765, 14.8922], + [73.6765, 15.7560] + ] + return ee.Geometry.Polygon(goa_coords) + +# Function to load fire events data +def load_fire_events(pa): + """ + Load fire events data from 2013-2023 and merge into a single feature collection. + + Args: + pa: ee.Geometry representing the study area + + Returns: + ee.FeatureCollection of fire events + """ + print("Loading fire events data...") + + # Load fire events data (2013-2019) + try: + # If the data is available in Earth Engine, you can load it directly + fire_13_19 = ee.FeatureCollection("users/your_username/fire13_19") + except: + # Otherwise, try to find and upload it, or use a placeholder + print("Fire data 2013-2019 not available in Earth Engine. Using placeholder.") + fire_13_19 = ee.FeatureCollection([]) + + # Load fire events data (2020-2023) + try: + # If the data is available in Earth Engine, you can load it directly + fire_20_23 = ee.FeatureCollection("users/your_username/fire20_23") + except: + # Otherwise, try to find and upload it, or use a placeholder + print("Fire data 2020-2023 not available in Earth Engine. Using placeholder.") + fire_20_23 = ee.FeatureCollection([]) + + # Merge the two collections + fire_all = fire_13_19.merge(fire_20_23) + + # Filter by the study area boundary + fire_all = fire_all.filterBounds(pa) + + # Add a 'year' property based on the acquisition date + def add_year(feature): + acq_date = ee.String(feature.get('ACQ_DATE')) + year = ee.Number.parse(acq_date.slice(0, 4)) + return feature.set('year', year) + + fire_all = fire_all.map(add_year) + + # Filter to include only 2013-2022 for training (2023 will be used for validation) + fire_training = fire_all.filter(ee.Filter.lt('year', 2023)) + + # Count the number of fire points + training_count = fire_training.size().getInfo() + print(f"Number of fire events for training (2013-2022): {training_count}") + + # Get 2023 fire events for validation + fire_validation = fire_all.filter(ee.Filter.eq('year', 2023)) + validation_count = fire_validation.size().getInfo() + print(f"Number of fire events for validation (2023): {validation_count}") + + return fire_all, fire_training, fire_validation + +# Function to load road data +def load_roads(pa): + """ + Load roads data and clip to the study area. + + Args: + pa: ee.Geometry representing the study area + + Returns: + ee.Image with roads data + """ + print("Loading roads data...") + + try: + # Try to load the road data from Earth Engine assets + roads = ee.Image("users/your_username/road").clip(pa) + return roads + except: + print("Road data not available in Earth Engine. Using OSM roads as fallback.") + # Use OpenStreetMap data as a fallback + roads = ee.FeatureCollection('OSM/2020/roads').filterBounds(pa) + + # Convert to an image + roads_image = roads.reduceToImage( + properties=['highway'], + reducer=ee.Reducer.first() + ).clip(pa) + + return roads_image + +# Function to generate random non-fire points +def generate_non_fire_points(pa, fire_training, num_points=100, buffer_distance=500): + """ + Generate random points for non-fire locations within the study area. + + Args: + pa: ee.Geometry representing the study area + fire_training: ee.FeatureCollection of fire points + num_points: Number of random points to generate + buffer_distance: Buffer distance (in meters) to avoid fire locations + + Returns: + ee.FeatureCollection of non-fire points + """ + print(f"Generating {num_points} random non-fire points...") + + # Create a buffer around fire points to avoid + fire_buffer = fire_training.geometry().buffer(buffer_distance) + + # Create a mask to avoid sampling in fire buffer zones + mask = ee.Image(1).clip(pa).updateMask( + ee.Image(1).clip(pa).mask().subtract( + ee.Image(1).clip(fire_buffer).mask() + ) + ) + + # Generate random points in the valid sampling area + non_fire_points = ee.FeatureCollection.randomPoints({ + 'region': pa, + 'points': num_points, + 'seed': 42, + 'mask': mask + }) + + # Add a risk property (0 for non-fire) + non_fire_points = non_fire_points.map(lambda f: f.set('RiskNumeric', 0)) + + # Check if we have enough points + point_count = non_fire_points.size().getInfo() + print(f"Generated {point_count} non-fire points") + + return non_fire_points + +# Function to calculate Land Surface Temperature trends from MODIS data +def calculate_lst_trends(pa, start_date='2013-01-01', end_date='2022-12-31'): + """ + Calculate Land Surface Temperature (LST) trends from MODIS data. + + Args: + pa: ee.Geometry representing the study area + start_date: Start date for trend calculation + end_date: End date for trend calculation + + Returns: + ee.Image with LST trend bands + """ + print("Calculating Land Surface Temperature trends...") + + # Function to mask clouds in MODIS LST imagery + def maskLstClouds(image): + qc = image.select('QC_Day') + # Bit 0-1: LST produced, good quality + mask = qc.bitwiseAnd(3).eq(0) + return image.updateMask(mask) + + # Load the MODIS LST data + modis_lst = ee.ImageCollection('MODIS/061/MOD11A1') \ + .filterDate(start_date, end_date) \ + .filterBounds(pa) + + # Apply cloud masking + modis_lst_masked = modis_lst.map(maskLstClouds) + + # Convert LST to Celsius + modis_lst_celsius = modis_lst_masked.map( + lambda image: image.select(['LST_Day_1km', 'LST_Night_1km']) + .multiply(0.02) + .subtract(273.15) + .copyProperties(image, ['system:time_start']) + ) + + # Function to add time band for trend calculation + def addTime(image): + # Get the timestamp and convert to years since start + year = ee.Date(image.get('system:time_start')).difference( + ee.Date(start_date), 'year') + return image.addBands(ee.Image(year).rename('t')) + + # Add time band to the collection + modis_lst_with_time = modis_lst_celsius.map(addTime) + + # Calculate trends for day and night LST + day_trend = modis_lst_with_time.select(['t', 'LST_Day_1km']) \ + .reduce(ee.Reducer.linearFit()) \ + .select(['scale'], ['lst_day_trend']) + + night_trend = modis_lst_with_time.select(['t', 'LST_Night_1km']) \ + .reduce(ee.Reducer.linearFit()) \ + .select(['scale'], ['lst_night_trend']) + + # Calculate delta LST (day-night) + def calculateDeltaLST(image): + day = image.select('LST_Day_1km') + night = image.select('LST_Night_1km') + delta = day.subtract(night).rename('delta_lst') + return image.addBands(delta) + + modis_lst_with_delta = modis_lst_celsius.map(calculateDeltaLST) + + # Calculate delta LST trend + delta_trend = modis_lst_with_delta.map(addTime) \ + .select(['t', 'delta_lst']) \ + .reduce(ee.Reducer.linearFit()) \ + .select(['scale'], ['delta_lst_trend']) + + # Merge all LST trend layers + lst_trends = day_trend.addBands(night_trend).addBands(delta_trend) + + return lst_trends.clip(pa) + +# Function to load trend layers from TrendFire output +def load_trend_layers(pa): + """ + Load trend layers previously calculated using TrendFire.py. + + Args: + pa: ee.Geometry representing the study area + + Returns: + ee.Image with all trend bands + """ + print("Loading trend layers...") + + try: + # Try to load the trend layers from Earth Engine assets + trends = ee.Image("users/your_username/goa_fire_trends").clip(pa) + print("Successfully loaded trend layers from Earth Engine asset.") + return trends + except: + print("Trend layers not found in Earth Engine assets. Calculating LST trends as fallback.") + # Calculate LST trends as a fallback + lst_trends = calculate_lst_trends(pa) + return lst_trends + +# Function to categorize fire risk based on temperature difference +def categorize_fire_risk(fire_training, lst_data, pa): + """ + Categorize fire points by risk level based on temperature difference. + + Args: + fire_training: ee.FeatureCollection of fire points + lst_data: ee.Image with LST data + pa: ee.Geometry representing the study area + + Returns: + ee.FeatureCollection of categorized fire points + """ + print("Categorizing fire risk levels...") + + # Sample the delta LST values at fire locations + fire_samples = lst_data.select('delta_lst_trend').sampleRegions({ + 'collection': fire_training, + 'properties': ['ACQ_DATE', 'year'], + 'scale': 1000, # MODIS LST resolution + 'geometries': True + }) + + # Define threshold values for risk categories + # These thresholds would need to be calibrated based on local conditions + def categorize(feature): + delta_lst = feature.get('delta_lst_trend') + + # Define risk categories based on delta LST + # 1: Low risk, 2: Moderate risk, 3: High risk + risk = ee.Algorithms.If(ee.Number(delta_lst).lt(0.1), 1, + ee.Algorithms.If(ee.Number(delta_lst).lt(0.2), 2, 3)) + + return feature.set('RiskNumeric', risk) + + # Apply categorization to all fire points + categorized_fire = fire_samples.map(categorize) + + # Count points in each risk category + low_risk = categorized_fire.filter(ee.Filter.eq('RiskNumeric', 1)).size().getInfo() + moderate_risk = categorized_fire.filter(ee.Filter.eq('RiskNumeric', 2)).size().getInfo() + high_risk = categorized_fire.filter(ee.Filter.eq('RiskNumeric', 3)).size().getInfo() + + print(f"Fire risk categorization: {low_risk} Low, {moderate_risk} Moderate, {high_risk} High risk") + + return categorized_fire + +# Function to prepare training data +def prepare_training_data(fire_points_input, boundary, predictor_image, label_property, \ + num_random_points=90, random_points_seed=42, \ + moderate_risk_limit=70, use_risk_categories=True): + """ + Prepares training and validation data by combining categorized fire points + with generated non-fire points and sampling predictor values. + + Args: + fire_points_input: ee.FeatureCollection of historical fire points. + Should contain 'Delta T' if use_risk_categories=True. + boundary: ee.Geometry defining the study area. + predictor_image: ee.Image containing all predictor bands. + label_property: String, the name of the property to use for classification label (e.g., 'RiskNumeric'). + num_random_points: Integer, number of random non-fire points to generate. + random_points_seed: Integer, seed for random point generation. + moderate_risk_limit: Integer, threshold for Delta T to limit moderate risk points (if used). + use_risk_categories: Boolean, if True, categorize fires (0=NoFire, 1=Low, 2=Moderate, 3=High). + If False, label all fires as 1 (binary fire/no-fire). + + Returns: + An ee.FeatureCollection containing sampled points with predictor values and the class label, + or None on error. + """ + print("\nPreparing training data...") + try: + # --- Categorize Fire Points --- + print("Categorizing fire points...") + no_fire_label = 0 + fire_label = 1 # Used if use_risk_categories is False + + if use_risk_categories: + # Use tqdm to show progress for client-side mapping/filtering if complex + # Note: The actual .map/.filter happens server-side, so tqdm only tracks + # the *creation* of these instructions, not their execution time. + print(" Defining fire risk categories (Low, Moderate, High)...") + low_risk = fire_points_input.filter(ee.Filter.rangeContains('Delta T', 0, 25))\ + .map(lambda f: f.set(label_property, 1).set('RiskCategory', 'Low Risk')) + moderate_risk = fire_points_input.filter(ee.Filter.rangeContains('Delta T', 25, 35))\ + .map(lambda f: f.set(label_property, 2).set('RiskCategory', 'Moderate Risk'))\ + .limit(moderate_risk_limit) # Limit moderate risk points like JS + high_risk = fire_points_input.filter(ee.Filter.greaterThanOrEquals('Delta T', 35))\ + .map(lambda f: f.set(label_property, 3).set('RiskCategory', 'High Risk')) + + # Get counts (these trigger computation) + print(" Fetching category counts...") + low_count = low_risk.size().getInfo() + mod_count = moderate_risk.size().getInfo() + high_count = high_risk.size().getInfo() + print(f" Low Risk (<25): {low_count}") + print(f" Moderate Risk (25-35, limited to {moderate_risk_limit}): {mod_count}") + print(f" High Risk (>=35): {high_count}") + + # Combine categorized fire points + categorized_fires = low_risk.merge(moderate_risk).merge(high_risk) + total_fires = categorized_fires.size().getInfo() + print(f" Total categorized fire points used: {total_fires}") + + else: + # Binary classification: Label all input fires as 1 + categorized_fires = fire_points_input.map(lambda f: f.set(label_property, fire_label)) + total_fires = categorized_fires.size().getInfo() + print(f" Using binary classification. Total fire points: {total_fires}") + + # --- Generate Non-Fire Points --- + print(f"Generating {num_random_points} random non-fire points...") + random_pts = ee.FeatureCollection.randomPoints( + region=boundary, + points=num_random_points, + seed=random_points_seed + ) + non_fire_pts = random_pts.map(lambda feat: feat.set(label_property, no_fire_label)) + non_fire_count = non_fire_pts.size().getInfo() + print(f" Generated {non_fire_count} non-fire points.") + + # --- Combine Fire and Non-Fire Points --- + training_validation_points = categorized_fires.merge(non_fire_pts) + total_points = training_validation_points.size().getInfo() + print(f"Total points for sampling: {total_points}") + + # --- Sample Predictor Values --- + print("\n>>> Sending request to GEE: Sample predictor values at points...") # Log Before + if predictor_image is None: + print("Error: Predictor image is missing.") + return None + if training_validation_points is None or total_points == 0: + print("Error: No training/validation points available for sampling.") + return None + + # Ensure predictor image bands are float for sampling/training + predictor_image = predictor_image.toFloat() + + # Define properties to keep (only the label) + properties_to_keep = [label_property] + + # Sample the regions + sampled_data = predictor_image.sampleRegions( + collection=training_validation_points, + properties=properties_to_keep, + scale=predictor_image.projection().nominalScale(), # Use image native scale + geometries=False # Don't need geometries for training + ) + + # Force execution and check size BEFORE adding random column + print(">>> Waiting for GEE: Sampling predictor values...") + sampled_size_check = sampled_data.size().getInfo() + print(f"<<< GEE Response: Sampling returned {sampled_size_check} features.") # Log After + + if sampled_size_check == 0: + print("Error: Sampling returned no features. Check predictor image, points, and permissions.") + return None + + # Add a random column for splitting later + print("Adding random column for train/test split...") + sampled_data = sampled_data.randomColumn(columnName='random', seed=random_points_seed) # Explicit column name and seed + # Verify random column exists (optional check) + # print("Properties after adding random column:", sampled_data.first().propertyNames().getInfo()) + + print("Training data preparation complete.") + return sampled_data + + except ee.EEException as e: + print(f"GEE error during training data preparation: {e}") + return None + except Exception as e: + print(f"Unexpected error during training data preparation: {e}") + return None + +# Function to train a Random Forest classifier +def train_classifier(training_data, class_property, input_properties, num_trees=1000, variables_per_split=1, seed=42): + """ + Trains the ee.Classifier.smileRandomForest classifier. + + Args: + training_data: ee.FeatureCollection used for training. + class_property: String, the name of the property containing the class label. + input_properties: List of strings, names of the predictor properties/bands. + num_trees: Integer, number of trees in the forest. + variables_per_split: Integer, number of variables to consider at each split. + Set to None or 0 to use sqrt(num_variables). + JS used 1. + seed: Integer, seed for reproducibility. + + Returns: + A trained ee.Classifier object, or None on error. + """ + print(f"Training Random Forest classifier with {num_trees} trees...") + + if training_data is None: + print("Error: Training data is missing.") + return None + if not input_properties: + print("Error: Input properties list is empty.") + return None + + try: + classifier = ee.Classifier.smileRandomForest( + numberOfTrees=num_trees, + variablesPerSplit=variables_per_split, # Match JS, using 1 + # minLeafPopulation=1, # Default is 1 + # bagFraction=0.5, # Default is 0.5 + seed=seed + ).train( + features=training_data, + classProperty=class_property, + inputProperties=input_properties + ) + + print("Classifier trained successfully.") + + # Optional: Explain the classifier (can be computationally intensive) + # try: + # explanation = classifier.explain() + # print("Classifier explanation:", explanation.getInfo()) + # importance = explanation.get('importance') + # if importance: + # print("Variable Importance:") + # importance_info = importance.getInfo() + # # Ensure importance_info is a dictionary before iterating + # if isinstance(importance_info, dict): + # for prop, imp in importance_info.items(): + # print(f" {prop}: {imp}") + # else: + # print(" Could not retrieve importance details in expected format.") + # except Exception as explain_e: + # print(f"Could not get classifier explanation: {explain_e}") + + return classifier + + except ee.EEException as e: + print(f"GEE error during classifier training: {e}") + return None + except Exception as e: + print(f"Unexpected error during classifier training: {e}") + return None + +# Function to validate the Random Forest model +def validate_model(classifier, predictor_names, validation_data): + """ + Validate the Random Forest model using test data. + + Args: + classifier: Trained ee.Classifier.RandomForest + predictor_names: List of predictor variable names + validation_data: ee.FeatureCollection with validation data + + Returns: + Dictionary with validation metrics + """ + print("Validating Random Forest model...") + + # Apply the classifier to the validation data + validated = validation_data.classify(classifier) + + # Get the confusion matrix + confusion_matrix = validated.errorMatrix('RiskNumeric', 'classification') + + # Calculate accuracy and Kappa statistics + accuracy = confusion_matrix.accuracy().getInfo() + kappa = confusion_matrix.kappa().getInfo() + + print(f"Validation accuracy: {accuracy:.4f}") + print(f"Kappa statistic: {kappa:.4f}") + + # Get confusion matrix as a list of lists + cm_data = confusion_matrix.getInfo() + + # Return validation metrics + return { + 'accuracy': accuracy, + 'kappa': kappa, + 'confusion_matrix': cm_data + } + +# Function to create a fire vulnerability map +def create_vulnerability_map(classifier, predictor_variables, predictor_names, pa): + """ + Create a fire vulnerability map using the trained classifier. + + Args: + classifier: Trained ee.Classifier.RandomForest + predictor_variables: ee.Image with predictor variables + predictor_names: List of predictor variable names + pa: ee.Geometry representing the study area + + Returns: + ee.Image with fire vulnerability classification + """ + print("Creating fire vulnerability map...") + + # Select only the predictor bands used for training + predictors = predictor_variables.select(predictor_names) + + # Apply the classifier to create a vulnerability map + vulnerability_map = predictors.classify(classifier).clip(pa) + + return vulnerability_map + +# Function to export the vulnerability map to Google Drive +def export_vulnerability_map(vulnerability_map, pa, filename='fire_vulnerability_map', folder='ForestFireGoa'): + """ + Export the fire vulnerability map to Google Drive. + + Args: + vulnerability_map: ee.Image with fire vulnerability classification + pa: ee.Geometry representing the study area + filename: Output filename + folder: Google Drive folder name + """ + print(f"Exporting fire vulnerability map to Google Drive folder '{folder}'...") + + # Start the export task + task = ee.batch.Export.image.toDrive({ + 'image': vulnerability_map, + 'description': filename, + 'folder': folder, + 'fileNamePrefix': filename, + 'region': pa, + 'scale': 30, + 'maxPixels': 1e13 + }) + + task.start() + print(f"Export task started with ID: {task.id}") + +# Function to export the vulnerability map to an Earth Engine asset +def export_vulnerability_map_to_asset(vulnerability_map, pa, asset_name): + """ + Export the fire vulnerability map to an Earth Engine asset. + + Args: + vulnerability_map: ee.Image with fire vulnerability classification + pa: ee.Geometry representing the study area + asset_name: Name of the Earth Engine asset + """ + print(f"Exporting fire vulnerability map to Earth Engine asset: {asset_name}") + + # Start the export task + task = ee.batch.Export.image.toAsset({ + 'image': vulnerability_map, + 'description': asset_name.split('/')[-1], + 'assetId': asset_name, + 'region': pa, + 'scale': 30, + 'maxPixels': 1e13 + }) + + task.start() + print(f"Export task started with ID: {task.id}") + +# Main function to run the fire vulnerability mapping workflow +def main(): + """Main script execution for fire vulnerability mapping.""" + # --- Configuration --- + PROJECT_ID = 'ee-crop-health-telangana' + BOUNDARY_ASSET_ID = 'users/jonasnothnagel/pa_boundary' + FIRE_ASSET_BASE = 'users/jonasnothnagel/' # Base for fire points (e.g., fire13_19, fire20_23) + DEM_ASSET_ID = 'users/jonasnothnagel/dem' + ROAD_ASSET_ID = 'users/jonasnothnagel/roads' + TRENDFIRE_ASSET_BASE = 'users/jonasnothnagel/' # Base for JS TrendFire outputs (e.g., Trend2023_ndvi) + NICFI_COLLECTION = 'projects/planet-nicfi/assets/basemaps/asia' + MODIS_LST_COLLECTION = 'MODIS/061/MOD11A1' + + # --- Option to use pre-computed resampled input --- # + USE_PRECOMPUTED_RESAMPLED = True # Set to True to load the asset below + PRECOMPUTED_RESAMPLED_ASSET = 'users/jonasnothnagel/inputResampled' # Asset ID of the uploaded 40-band tif + # ---------------------------------------------------- # + + OUTPUT_ASSET_BASE = 'users/jonasnothnagel/' + VULNERABILITY_MAP_ASSET = OUTPUT_ASSET_BASE + 'FireVulnerability_py' + # Asset ID for the resampled image *generated* by this script (if USE_PRECOMPUTED_RESAMPLED=False) + GENERATED_RESAMPLED_FEATURES_ASSET = OUTPUT_ASSET_BASE + 'FireVulnerability_InputsGenerated_py' + TRAINING_POINTS_ASSET = OUTPUT_ASSET_BASE + 'FireVulnerability_TrainingPoints_py' + + GRID_SCALE = 30 + GRID_CRS = 'EPSG:3857' + NUM_RANDOM_POINTS = 90 # Match JS + RF_TREES = 1000 # Match JS + RF_VAR_SPLIT = 1 # Match JS + TRAIN_TEST_SPLIT_RATIO = 0.8 + CLASS_LABEL = 'RiskNumeric' + # Use Delta T categories (True) or binary fire/no-fire (False) + # JS used only high risk (Delta T >= 35) vs non-fire (0). Setting this to True enables categorization, + # but prepare_training_data currently merges all categories or uses binary. + # To exactly match JS sampling, logic inside prepare_training_data needs adjustment. + USE_RISK_CATEGORIES = True + RANDOM_SEED = 42 # For reproducibility in random points and RF training + + # --- Initialization --- + initialize_ee(PROJECT_ID) + boundary = get_boundary(BOUNDARY_ASSET_ID) + if not boundary: + return + + # --- Processing Steps --- + print("\n--- Starting Fire Vulnerability Workflow ---") + + input_resampled = None # This will hold the final predictor image for sampling/classification + fire_pts_processed = None # To hold loaded fire points + + # --- Mode 1: Load Precomputed Resampled Input --- # + if USE_PRECOMPUTED_RESAMPLED: + print(f"---> Mode: Using Precomputed Input <---") + print(f"Attempting to load pre-computed resampled input: {PRECOMPUTED_RESAMPLED_ASSET}") + try: + input_resampled = ee.Image(PRECOMPUTED_RESAMPLED_ASSET).toFloat() # Ensure float + # Verify it has bands + if not input_resampled.bandNames().getInfo(): + raise ee.EEException(f"Loaded asset {PRECOMPUTED_RESAMPLED_ASSET} has no bands.") + print("Successfully loaded pre-computed resampled input.") + print("Skipping intermediate data loading, combining, and resampling steps.") + # Load fire points separately as they are needed for training data prep + fire_pts_processed = load_fire_points(FIRE_ASSET_BASE, boundary) + if fire_pts_processed is None: + print("Error: Failed to load fire points even when using precomputed input. Exiting.") + return + except ee.EEException as e: + print(f"Error loading pre-computed asset '{PRECOMPUTED_RESAMPLED_ASSET}': {e}") + print("Exiting. Cannot proceed without input features.") + return # Exit if loading precomputed fails + except Exception as e: + print(f"Unexpected error loading pre-computed asset: {e}") + print("Exiting. Cannot proceed without input features.") + return # Exit if loading precomputed fails + + # --- Mode 2: Generate Inputs from Components --- # + if input_resampled is None: # This block runs if USE_PRECOMPUTED_RESAMPLED is False or loading failed + print("---> Mode: Generating Input Features from Components <--- ") + # 1. Load Fire Points (needed regardless for training data) + fire_pts_processed = load_fire_points(FIRE_ASSET_BASE, boundary) + if fire_pts_processed is None: + print("Exiting: Failed to load fire points.") + return + + # 2. Process NICFI (Optional) + nicfi_trends = process_nicfi(boundary) + if nicfi_trends is None: + print("Warning: Failed to process NICFI trends. Proceeding without them.") + + # 3. Process MODIS LST (Optional) + modis_trends = process_modis_lst(boundary) + if modis_trends is None: + print("Warning: Failed to process MODIS LST trends. Proceeding without them.") + + # 4. Load DEM Slope + dem_slope = load_dem_slope(DEM_ASSET_ID, boundary) + if dem_slope is None: + print("Warning: Failed to process DEM slope. Proceeding without it.") + + # 5. Load Roads + roads_img = load_roads(ROAD_ASSET_ID, boundary) # Corrected arguments + if roads_img is None: + print("Warning: Failed to process Roads layer. Proceeding without it.") + + # 6. Load TrendFire Outputs (Core Trends) + trendfire_img = load_trendfire_outputs(TRENDFIRE_ASSET_BASE, boundary) + if trendfire_img is None: + print("Exiting: Failed to load TrendFire outputs.") + return + + # 7. Combine Available Features + print("Combining available features...") + combined_features = combine_features(trendfire_img, nicfi_trends, modis_trends, dem_slope, roads_img) + if combined_features is None or not combined_features.bandNames().getInfo(): + print("Exiting: Failed to combine input features or resulting image has no bands.") + return + print(f"Combined features image created with bands: {combined_features.bandNames().getInfo()}") + + # 8. Resample & Export Generated Intermediate Input + print(f"Resampling combined features to {GRID_SCALE}m scale, CRS {GRID_CRS}...") + input_resampled = resample_features(combined_features, GRID_SCALE, GRID_CRS, boundary) + if input_resampled is None or not input_resampled.bandNames().getInfo(): + print("Exiting: Failed to resample features or resulting image has no bands.") + return + print("Resampling complete.") + + # Export the generated resampled image for comparison/debugging + print(f"Exporting the generated resampled input features to asset: {GENERATED_RESAMPLED_FEATURES_ASSET}") + export_asset(input_resampled, GENERATED_RESAMPLED_FEATURES_ASSET, boundary, "Generated_Inputs_FV_py", GRID_SCALE, GRID_CRS) + + # --- Classification Workflow (Uses the selected 'input_resampled') --- # + if input_resampled is None or fire_pts_processed is None: + print("Error: Cannot proceed to classification. Missing resampled input image or fire points.") + return + + print(f"\nProceeding with classification using predictor image with bands: {input_resampled.bandNames().getInfo()}") + + # 9. Prepare Training Data + training_data_fc = prepare_training_data( + fire_points_input=fire_pts_processed, + boundary=boundary, + predictor_image=input_resampled, + label_property=CLASS_LABEL, + num_random_points=NUM_RANDOM_POINTS, + random_points_seed=RANDOM_SEED, + use_risk_categories=USE_RISK_CATEGORIES + ) + if training_data_fc is None: + print("Exiting: Failed to prepare training data.") + return + + # Export the full sampled dataset before splitting (useful for external analysis) + export_table(training_data_fc, TRAINING_POINTS_ASSET, "Training_Validation_Points_FV_py") + + # 10. Split Data + print(f"Splitting data using ratio: {TRAIN_TEST_SPLIT_RATIO:.1f} train / {1-TRAIN_TEST_SPLIT_RATIO:.1f} validation...") + # Filter based on the random column added in prepare_training_data + training_sample = training_data_fc.filter(ee.Filter.lt('random', TRAIN_TEST_SPLIT_RATIO)) + validation_sample = training_data_fc.filter(ee.Filter.gte('random', TRAIN_TEST_SPLIT_RATIO)) + train_count = training_sample.size().getInfo() + val_count = validation_sample.size().getInfo() + print(f" Training samples: {train_count}, Validation samples: {val_count}") + if train_count == 0 or val_count == 0: + print("Error: Training or validation sample is empty after splitting. Check data preparation.") + return + + # Get predictor names from the resampled image (used as input properties for RF) + predictor_names = input_resampled.bandNames() + if not predictor_names.getInfo(): + print("Error: Could not retrieve band names from the input predictor image.") + return + + # 11. Train Classifier + print("\n>>> Sending request to GEE: Train Random Forest classifier...") # Log Before + classifier = train_classifier( + training_data=training_sample, + class_property=CLASS_LABEL, + input_properties=predictor_names, # Pass Python list + num_trees=RF_TREES, + variables_per_split=RF_VAR_SPLIT, + seed=RANDOM_SEED + ) + # Note: train() itself can take time, but the result (trained classifier object) + # is usually returned quickly to the client unless explain() is called. + # The heavy lifting happens when classifier.classify() is called. + print("<<< GEE Response: Classifier training definition complete.") # Log After + + if classifier is None: + print("Exiting: Classifier training failed.") + return + + # 12. Evaluate Classifier + print("\n>>> Sending request to GEE: Evaluate classifier...") # Log Before + evaluation_results = evaluate_classifier(classifier, validation_sample, CLASS_LABEL) + print("<<< GEE Response: Evaluation complete.") # Log After + + # evaluation_results is a dictionary containing accuracy, kappa, matrix etc. + if evaluation_results is None: + print("Warning: Classifier evaluation step failed or produced no results.") + + # 13. Classify Image + print("\n>>> Sending request to GEE: Classify the full predictor image...") # Log Before + # Ensure the image being classified has float type bands (required by some classifiers) + vulnerability_map = input_resampled.toFloat().classify(classifier) + # Force execution by getting some info (optional, but confirms the step is done) + # print(">>> Waiting for GEE: Classification...") + # _ = vulnerability_map.bandNames().getInfo() # Or use another light .getInfo() call + print("<<< GEE Response: Classification definition complete.") # Log After + + # 14. Export Final Map + print(f"\nExporting final Fire Vulnerability Map to asset:") + print(f" {VULNERABILITY_MAP_ASSET}") + export_asset( + image=vulnerability_map.toInt8(), # Classifiers output integer labels, cast to save space + asset_id=VULNERABILITY_MAP_ASSET, + region=boundary, + description="Fire_Vulnerability_Map_py", + scale=GRID_SCALE, + crs=GRID_CRS + ) + + print("\n--- Fire Vulnerability Workflow Completed --- ") + print("Monitor GEE tasks dashboard for export completion.") + +# --- Fire Vulnerability Specific Functions --- + +def load_fire_points(asset_base, boundary): + """ + Loads historical fire point assets, merges them, and filters out 2023 data. + + Args: + asset_base: String, the base path for fire point assets (e.g., 'users/username/'). + boundary: ee.Geometry object for optional filtering (though JS didn't explicitly filter here). + + Returns: + An ee.FeatureCollection containing fire points from 2013-2022, or None on error. + """ + print("Loading and preparing historical fire points...") + fire_asset_13_19 = asset_base + 'fire13_19' + fire_asset_20_23 = asset_base + 'fire20_23' + + try: + print(f" Loading {fire_asset_13_19}...") + fire13_19 = ee.FeatureCollection(fire_asset_13_19) + print(f" Loading {fire_asset_20_23}...") + fire20_23 = ee.FeatureCollection(fire_asset_20_23) + + # Merge the collections + fire13_23 = fire13_19.merge(fire20_23) + print(f" Merged collections. Total points (2013-2023): {fire13_23.size().getInfo()}") + + # Filter out points from 2023 based on the 'acq_date' property + # Assumes 'acq_date' format allows simple string filtering like 'YYYY-MM-DD' + fire13_22 = fire13_23.filter(ee.Filter.stringContains('acq_date', '-2023').Not()) + # Alternative filter if acq_date is ee.Date object: + # fire13_22 = fire13_23.filter(ee.Filter.date('2013-01-01', '2022-12-31')) + + print(f" Filtered out 2023 points. Total points (2013-2022): {fire13_22.size().getInfo()}") + + # Optional: Filter by boundary if needed, although JS didn't seem to do it here + # fire13_22 = fire13_22.filterBounds(boundary) + # print(f" Filtered by boundary. Points within boundary: {fire13_22.size().getInfo()}") + + return fire13_22 + + except ee.EEException as e: + print(f"Error loading or processing fire point assets: {e}") + print(f"Please ensure assets '{fire_asset_13_19}' and '{fire_asset_20_23}' exist and properties like 'acq_date' are correct.") + return None + except Exception as e: + print(f"An unexpected error occurred loading fire points: {e}") + return None + +def process_nicfi(boundary, start_date='2016-03-01', end_date='2024-02-28', collection_id='projects/planet-nicfi/assets/basemaps/asia'): + """ + Loads Planet-NICFI data, calculates NDVI, and computes trends for R, G, B, N, NDVI bands. + + Args: + boundary: ee.Geometry for filtering and clipping. + start_date: Start date for filtering NICFI data. + end_date: End date for filtering NICFI data. + collection_id: GEE asset ID for the NICFI collection. + + Returns: + ee.Image containing slope and intercept bands for R, G, B, N, NDVI, or None on error. + """ + print(f"Processing NICFI trends ({start_date} to {end_date})...") + + try: + # Load the collection + nicfi_col = ee.ImageCollection(collection_id) \ + .map(lambda img: img.clip(boundary)) \ + .filterDate(start_date, end_date) + + # Function to calculate and add NDVI band + def addNDVI(image): + # Ensure bands are correctly named ('N', 'R', 'G', 'B') + # May need to rename depending on the specific NICFI collection version + # Example: .select(['B4', 'B3', 'B2', 'B1'], ['N', 'R', 'G', 'B']) if needed + ndvi = image.normalizedDifference(['N', 'R']).rename('NDVI') + return image.addBands(ndvi) + + nicfi_col = nicfi_col.map(addNDVI) + + # Add time band (years since 2016-01-01, as per JS) + ref_date = ee.Date('2016-01-01') + def addTime(image): + img_date = image.date() + years = img_date.difference(ref_date, 'year') + return image.addBands(ee.Image(years).rename('time').float()) + + nicfi_col_time = nicfi_col.map(addTime) + + # Indices for trend calculation + indices = ['R', 'G', 'B', 'N', 'NDVI'] + combined_trends = ee.Image().toFloat() # Start empty + + # Calculate trends for each index + for index in indices: + print(f" Calculating NICFI trend for: {index}") + stacked = nicfi_col_time.select(['time', index]) + regression = stacked.reduce(ee.Reducer.linearFit()) # Outputs 'scale' and 'offset' + slope = regression.select('scale').rename(f'{index}_Slope') + intercept = regression.select('offset').rename(f'{index}_Intercept') + combined_trends = combined_trends.addBands(slope).addBands(intercept) + + print("NICFI trends calculated successfully.") + return combined_trends + + except ee.EEException as e: + print(f"GEE error during NICFI processing: {e}") + print(f"Please ensure you have access to the collection: {collection_id}") + return None + except Exception as e: + print(f"Unexpected error during NICFI processing: {e}") + return None + +def process_modis_lst(boundary, start_date='2013-01-01', end_date='2023-02-28', collection_id='MODIS/061/MOD11A1'): + """ + Loads MODIS LST data, masks clouds, converts to Celsius, and computes trends for Day and Night LST. + + Args: + boundary: ee.Geometry for filtering and clipping. + start_date: Start date for filtering MODIS data. + end_date: End date for filtering MODIS data. + collection_id: GEE asset ID for the MODIS LST collection. + + Returns: + ee.Image containing slope and intercept bands for LST_Day and LST_Night, or None on error. + """ + print(f"Processing MODIS LST trends ({start_date} to {end_date})...") + + try: + # Function to mask clouds/poor quality pixels and convert units + def scale_and_mask_lst(image): + qc = image.select('QC_Day') + # Keep only pixels with good quality (Bits 0-1: 00 = Good) + mask = qc.bitwiseAnd(3).eq(0) + + lst_day_c = image.select('LST_Day_1km') \ + .updateMask(mask) \ + .multiply(0.02) \ + .subtract(273.15) \ + .rename('LST_Day') + + lst_night_c = image.select('LST_Night_1km') \ + .updateMask(mask) \ + .multiply(0.02) \ + .subtract(273.15) \ + .rename('LST_Night') + + return image.addBands(lst_day_c).addBands(lst_night_c).select(['LST_Day', 'LST_Night']) + + # Load, filter, and process the collection + modis_lst_col = ee.ImageCollection(collection_id) \ + .filterDate(start_date, end_date) \ + .filterBounds(boundary) \ + .map(scale_and_mask_lst) + + # Add time band + ref_date = ee.Date(start_date) + def addTime(image): + img_date = image.date() + years = img_date.difference(ref_date, 'year') + return image.addBands(ee.Image(years).rename('time').float()) + + modis_col_time = modis_lst_col.map(addTime) + + # Calculate trends for Day and Night LST + trends_list = [] + for band in ['LST_Day', 'LST_Night']: + print(f" Calculating MODIS trend for: {band}") + stacked = modis_col_time.select(['time', band]) + regression = stacked.reduce(ee.Reducer.linearFit()) # scale, offset + slope = regression.select('scale').rename(f'{band}_Slope') + intercept = regression.select('offset').rename(f'{band}_Intercept') + trends_list.append(slope.addBands(intercept)) + + # Combine Day and Night trends + if not trends_list: + print("Error: Could not calculate any MODIS LST trends.") + return None + + combined_trends = ee.ImageCollection(trends_list).toBands() + # Rename bands from 0_LST_Day_Slope etc. to LST_Day_Slope etc. + original_band_names = [img.bandNames() for img in trends_list] + flat_band_names = [item for sublist in original_band_names for item in sublist.getInfo()] + combined_trends = combined_trends.rename(flat_band_names) + + print("MODIS LST trends calculated successfully.") + return combined_trends.clip(boundary) # Clip final result + + except ee.EEException as e: + print(f"GEE error during MODIS LST processing: {e}") + return None + except Exception as e: + print(f"Unexpected error during MODIS LST processing: {e}") + return None + +def load_dem_slope(asset_id, boundary): + """Loads DEM asset, calculates slope, and clips to boundary.""" + print(f"Loading DEM ({asset_id}) and calculating slope...") + try: + dem = ee.Image(asset_id) + slope = ee.Terrain.slope(dem) + print("Slope calculated successfully.") + return slope.clip(boundary) # Return only the slope band, clipped + except ee.EEException as e: + print(f"GEE error loading DEM or calculating slope: {e}") + return None + except Exception as e: + print(f"Unexpected error during DEM/Slope processing: {e}") + return None + +def load_roads(asset_id, boundary): + """Loads the road layer asset and clips to boundary.""" + print(f"Loading roads layer ({asset_id})...") + try: + roads_img = ee.Image(asset_id) + print("Roads layer loaded successfully.") + return roads_img.clip(boundary) + except ee.EEException as e: + print(f"GEE error loading roads asset: {e}") + return None + except Exception as e: + print(f"Unexpected error during roads processing: {e}") + return None + +def load_trendfire_outputs(asset_base, boundary): + """ + Loads the individual trend assets generated by TrendFire.js and merges them. + Assumes assets are under the user's GEE path (asset_base). + + Args: + asset_base: String, the base path for trend assets (e.g., 'users/username/'). + boundary: ee.Geometry object for clipping. + + Returns: + ee.Image containing all merged trend bands (Slope and Intercept), or None on error. + """ + print(f"Loading TrendFire outputs from base path: {asset_base}...") + + # Define asset names/parts based on TrendFire.js export structure + landsat_indices = ['ndvi', 'evi', 'mirbi', 'ndfi', 'bsi', 'ndmi', 'nbr', 'nbr2', 'msavi', 'smi', 'ST_B10'] + # JS exported these as 'users/sravanthi_earthAnalytics/Trend2023_' + indexName + # Assuming user ran JS and exported to their own folder: + landsat_asset_prefix = 'Trend2023_' + rain_asset_id_part = 'Trend2022_rain_new' + sm_asset_id_part = 'Trend2023_SM_new' + # JS asset was 'Trend2024_RH_new' + rh_asset_id_part = 'Trend2024_RH_new' + + all_trend_bands = ee.Image().toFloat() # Start with an empty image + asset_id = '' # For error message context + + try: + # Load Landsat index trends + for index in landsat_indices: + asset_id = f"{asset_base}{landsat_asset_prefix}{index}" + print(f" Loading Landsat trend: {asset_id}") + trend_img = ee.Image(asset_id) + all_trend_bands = all_trend_bands.addBands(trend_img) + + # Load Rain trend + asset_id = f"{asset_base}{rain_asset_id_part}" + print(f" Loading Rain trend: {asset_id}") + rain_trend = ee.Image(asset_id) + all_trend_bands = all_trend_bands.addBands(rain_trend) + + # Load SM trend + asset_id = f"{asset_base}{sm_asset_id_part}" + print(f" Loading SM trend: {asset_id}") + sm_trend = ee.Image(asset_id) + # Check expected bands: sm_surface_Slope, sm_surface_Intercept + # Rename if necessary, e.g., if JS exported with different names + # sm_trend = sm_trend.rename(['sm_surface_Slope', 'sm_surface_Intercept']) + all_trend_bands = all_trend_bands.addBands(sm_trend) + + # Load RH trend + asset_id = f"{asset_base}{rh_asset_id_part}" + print(f" Loading RH trend: {asset_id}") + rh_trend = ee.Image(asset_id) + all_trend_bands = all_trend_bands.addBands(rh_trend) + + print("Successfully loaded and merged TrendFire outputs.") + # Clip the final merged image to the boundary + return all_trend_bands.clip(boundary) + + except ee.EEException as e: + print(f"Error loading GEE asset during TrendFire output loading: {e}") + print(f"Please ensure asset '{asset_id}' exists and you have permissions.") + return None + except Exception as e: + print(f"An unexpected error occurred loading TrendFire outputs: {e}") + return None + +def combine_features(trendfire_img, nicfi_trends, modis_trends, dem_slope, roads_img): + """ + Combines all input feature bands into a single ee.Image. + Handles potential None inputs from previous steps. + + Args: + trendfire_img: ee.Image with TrendFire trend bands. + nicfi_trends: ee.Image with NICFI trend bands. + modis_trends: ee.Image with MODIS LST trend bands. + dem_slope: ee.Image with the DEM slope band. + roads_img: ee.Image with the roads layer. + + Returns: + A single ee.Image containing all combined bands, or None if essential inputs are missing. + """ + print("Combining input features...") + + # Check for essential inputs (can adjust based on importance) + if trendfire_img is None: + print("Error: TrendFire outputs are missing. Cannot combine features.") + return None + # Add checks for other inputs if they are considered essential + # if nicfi_trends is None: ... etc. + + # Start with the primary trend image + combined = trendfire_img.toFloat() # Ensure consistent type + + # Add other layers conditionally + if nicfi_trends is not None: + print(" Adding NICFI trends...") + combined = combined.addBands(nicfi_trends.toFloat()) + else: + print(" Warning: Skipping NICFI trends (input was None).") + + if modis_trends is not None: + print(" Adding MODIS LST trends...") + combined = combined.addBands(modis_trends.toFloat()) + else: + print(" Warning: Skipping MODIS LST trends (input was None).") + + if dem_slope is not None: + print(" Adding DEM slope...") + # Ensure DEM slope band has a unique name if needed (e.g., if 'slope' already exists) + # dem_slope = dem_slope.select('slope').rename('dem_slope') + combined = combined.addBands(dem_slope.toFloat()) # Assumes dem_slope is single band 'slope' + else: + print(" Warning: Skipping DEM slope (input was None).") + + if roads_img is not None: + print(" Adding Roads layer...") + # Ensure roads image band has a unique name (e.g., rename if it's just 'b1') + # roads_img = roads_img.rename('roads') + combined = combined.addBands(roads_img.toFloat()) + else: + print(" Warning: Skipping Roads layer (input was None).") + + print("Features combined successfully.") + # print("Combined bands:", combined.bandNames().getInfo()) # Optional: Verify bands + return combined + +def resample_features(feature_image, scale, crs, boundary): + """ + Resamples the combined feature image to a target CRS and scale. + Uses reduceResolution followed by reproject, matching the JS approach. + + Args: + feature_image: ee.Image with all combined feature bands. + scale: Target resolution in meters (e.g., 30). + crs: Target CRS string (e.g., 'EPSG:3857'). + boundary: ee.Geometry for clipping the final output. + + Returns: + A resampled ee.Image or None on error. + """ + print(f"Resampling features to {scale}m scale, CRS {crs}...") + if feature_image is None: + print("Error: Input feature_image is None. Cannot resample.") + return None + + try: + # Define the target projection + target_projection = ee.Projection(crs).atScale(scale) + + # Resample using reduceResolution followed by reproject + resampled_image = feature_image \ + .reduceResolution(reducer=ee.Reducer.mean(), maxPixels=1024) \ + .reproject(crs=target_projection) + + print("Resampling completed successfully.") + return resampled_image.clip(boundary) + + except ee.EEException as e: + print(f"GEE error during resampling: {e}") + return None + except Exception as e: + print(f"Unexpected error during resampling: {e}") + return None + +def evaluate_classifier(classifier, validation_data, class_property): + """ + Evaluates the classifier on validation data using an error matrix. + + Args: + classifier: Trained ee.Classifier object. + validation_data: ee.FeatureCollection used for validation. + class_property: String, the name of the property containing the true class label. + + Returns: + A dictionary containing accuracy, kappa, and the confusion matrix, or None on error. + """ + print("Evaluating classifier...") + if classifier is None: + print("Error: Classifier object is missing.") + return None + if validation_data is None: + print("Error: Validation data is missing.") + return None + + try: + # Classify the validation data + validated = validation_data.classify(classifier) + + # Calculate the error matrix + # Arguments are (actual, predicted) + error_matrix = validated.errorMatrix(class_property, 'classification') + + # Extract metrics + accuracy = error_matrix.accuracy() + kappa = error_matrix.kappa() + confusion = error_matrix.array() # Get the matrix as an ee.Array + + # Get results - use getInfo() to bring server-side objects to client + accuracy_val = accuracy.getInfo() + kappa_val = kappa.getInfo() + confusion_val = confusion.getInfo() + + print(f" Validation Overall Accuracy: {accuracy_val:.4f}") + print(f" Validation Kappa Coefficient: {kappa_val:.4f}") + print(" Validation Confusion Matrix:") + # Pretty print the matrix (assuming simple 2x2 or small matrix) + if confusion_val: + for row in confusion_val: + print(f" {row}") + else: + print(" Could not retrieve confusion matrix details.") + + return { + 'accuracy': accuracy_val, + 'kappa': kappa_val, + 'confusion_matrix': confusion_val + } + + except ee.EEException as e: + print(f"GEE error during classifier evaluation: {e}") + return None + except Exception as e: + print(f"Unexpected error during classifier evaluation: {e}") + return None + +# --- Reusable Helper Functions (Consider placing in a shared utils.py) --- + +def initialize_ee(project_id='ee-crop-health-telangana'): # Use the verified project ID + """Initializes the Earth Engine API.""" + try: + # ee.Authenticate() # Often needed only once per session/machine + ee.Initialize(project=project_id, opt_url='https://earthengine-highvolume.googleapis.com') + print(f"Earth Engine API initialized successfully for project: {project_id}") + except ee.EEException as e: + print(f"Error initializing Earth Engine API for project {project_id}: {e}") + print("Please ensure:") + print(" 1. You have authenticated (e.g., via `gcloud auth application-default login`).") + print(f" 2. The project ID '{project_id}' is correct.") + print(" 3. The Earth Engine API is enabled for this project in Google Cloud Console.") + print(" 4. The account used for authentication has access to this project.") + raise # Re-raise the exception to stop execution if initialization fails + except Exception as e: + # Catch other potential errors during initialization + print(f"An unexpected error occurred during Earth Engine initialization: {e}") + raise + +def get_boundary(asset_id='users/jonasnothnagel/pa_boundary'): + """ + Get the boundary geometry from the GEE asset. + Returns an ee.Geometry object. + """ + try: + print(f"Loading boundary from GEE asset: {asset_id}...") + fc = ee.FeatureCollection(asset_id) + if fc.size().getInfo() == 0: + print(f"Error: Asset {asset_id} is empty or inaccessible.") + return None + boundary_geom = fc.geometry().dissolve() + print("Successfully loaded boundary from GEE asset.") + return boundary_geom + except ee.EEException as e: + print(f"Error loading boundary asset {asset_id}: {e}") + return None + except Exception as e: + print(f"An unexpected error occurred loading the boundary asset: {e}") + return None + +def export_asset(image, asset_id, region, description=None, scale=30, crs='EPSG:3857'): + """Exports an image to a GEE asset, deleting if exists.""" + if description is None: + description = asset_id.split('/')[-1] + # Check and delete existing asset + try: + # Use ee.data.deleteAsset for deleting + asset_info = ee.data.getInfo(asset_id) # Check existence first + if asset_info: + print(f"Deleting existing asset: {asset_id}...") + ee.data.deleteAsset(asset_id) + print(f"Deleted existing asset: {asset_id}") + except ee.EEException as e: + # Catch specific exception for asset not found + if 'not found' in str(e).lower(): + print(f"Asset {asset_id} not found. Proceeding...") + else: + # Re-raise other GEE errors during check/delete attempt + print(f"GEE error checking/deleting asset {asset_id}: {e}. Proceeding attempt...") + except Exception as e: + # Catch unexpected errors during check/delete + print(f"Unexpected error checking/deleting asset {asset_id}: {e}. Proceeding attempt...") + + print(f"Starting export task to Asset: {description} (ID: {asset_id})") + task = ee.batch.Export.image.toAsset( + image=image.toFloat(), + description=description, + assetId=asset_id, + region=region, + scale=scale, + crs=crs, + maxPixels=1e13 + ) + task.start() + print(f"Task started (id: {task.id}). Check GEE Tasks.") + return task + +def export_table(collection, asset_id, description=None): + """Exports a FeatureCollection to a GEE asset.""" + if description is None: + description = asset_id.split('/')[-1] + # Check and delete existing asset + try: + asset_info = ee.data.getInfo(asset_id) # Check existence first + if asset_info: + print(f"Deleting existing asset table: {asset_id}...") + ee.data.deleteAsset(asset_id) + print(f"Deleted existing asset table: {asset_id}") + except ee.EEException as e: + if 'not found' in str(e).lower(): + print(f"Asset table {asset_id} not found. Proceeding...") + else: + print(f"GEE error checking/deleting asset table {asset_id}: {e}. Proceeding...") + except Exception as e: + print(f"Unexpected error checking/deleting asset table {asset_id}: {e}. Proceeding...") + + print(f"Starting export task to Table Asset: {description} (ID: {asset_id})") + task = ee.batch.Export.table.toAsset( + collection=collection, + description=description, + assetId=asset_id, + ) + task.start() + print(f"Table export task started (id: {task.id}). Check GEE Tasks.") + return task + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/README.md b/README.md index ef8410c..23755b6 100644 --- a/README.md +++ b/README.md @@ -3,41 +3,67 @@ **Forest fire vulnerability and prediction using vegetation indices anomaly, surface temperature anomaly, and meteorological parameters' anomaly in Google Earth Engine (GEE).** ## Overview -This project analyzes forest fire vulnerability and predicts potential fire-prone areas using long-term trends in vegetation indices, burn indices, and meteorological parameters. The methodology leverages Google Earth Engine (GEE) for data processing and analysis. - -## Methodology -1. **Calculate Decadal Trends** - - Generate long-term trends for vegetation and burn indices using Landsat imagery. - - Compute trends for meteorological parameters such as rainfall and relative humidity. -2. **Fire Vulnerability Mapping** - - Use historical fire events and trend layers to assess vulnerability. - - Identify areas most susceptible to fires. -3. **Fire Prediction** - - Utilize trend layers to predict high-risk fire zones in the near future. - -## Execution Sequence -### 1. Trend Calculation (`Trendfire.js`) - - **Input:** `pa_boundary` - - **Output:** The output consists of 19 trend layers with 2 bands in each layer representing long-term changes in vegetation, burn indices, and meteorological parameters along with 2 constant layers of DEM and road (Proximity to road in tif format) combined into one tif file with 40 bands. This inputResampled.tif file can be generated using the trendFire.js or can be downloaded from here - https://www.dropbox.com/scl/fi/ena1qfeqv5ppshluop8kt/inputResampled.tif?rlkey=arefwl3my7nx3z5qpknu88lsx&st=vj8cn3bd&dl=0 - -### 2. Fire Vulnerability Mapping (`FireVulnerability.js`) +This project analyzes forest fire vulnerability and predicts potential fire-prone areas using long-term trends in vegetation indices, burn indices, and meteorological parameters. The methodology leverages Google Earth Engine (GEE) for data processing and analysis, with implementations available in both JavaScript (original) and Python. + +## Methodology Summary +1. **Calculate Decadal Trends:** Generate long-term linear trends (Slope and Intercept) for various environmental indicators (vegetation indices, LST, precipitation, soil moisture, humidity) using historical satellite and climate data. +2. **Map Fire Vulnerability:** Develop a spatial model using machine learning (Random Forest) trained on historical fire locations, environmental trends, and static factors (topography, roads) to map the inherent susceptibility of different areas to fire. +3. **Predict Near-Term Fire Risk using Anomalies:** Identify areas where recent environmental conditions deviate significantly from their long-term trends, potentially indicating heightened short-term fire risk. + +## Execution Sequence & Scripts + +### 1. Trend Calculation (`Trendfire.js` / `TrendFire.py`) + - **Goal:** Calculate long-term (typically decadal) linear trends (Slope and Intercept) for key environmental indicators. + - **Input:** Study area boundary (e.g., `pa_boundary` GEE asset). + - **Datasets Used:** Landsat 8 (Vegetation/Burn Indices, LST), CHIRPS Daily (Precipitation), SMAP (Soil Moisture), ERA5-Land Monthly (Relative Humidity). + - **Method:** Filters datasets by date and boundary, applies masking (e.g., clouds), calculates relevant indices/parameters, and fits a linear trend over time for each pixel using `ee.Reducer.linearFit()`. + - **Output:** The output consists of 19 trend layers with 2 bands in each layer representing long-term changes in vegetation, burn indices, and meteorological parameters along with 2 constant layers of DEM and road (Proximity to road in tif format) combined into one tif file with 40 bands. This inputResampled.tif file can be generated using the trendFire.js or can be downloaded from here - https://www.dropbox.com/scl/fi/ena1qfeqv5ppshluop8kt/inputResampled.tif?rlkey=arefwl3my7nx3z5qpknu88lsx&st=vj8cn3bd&dl=0. The Python version can optionally export a single merged asset containing all trend bands. + +### 2. Fire Vulnerability Mapping (`FireVulnerability.js` / `FireVulnerability.py`) + - **Goal:** Map the inherent, long-term susceptibility of areas to fire based on environmental factors and historical fire patterns. - **Inputs:** - - Trend layers - https://www.dropbox.com/scl/fi/ena1qfeqv5ppshluop8kt/inputResampled.tif?rlkey=arefwl3my7nx3z5qpknu88lsx&st=vj8cn3bd&dl=0 - - Roads - - DEM (Digital Elevation Model) - - Fire event datasets (`fire13_19` and `fire20_23`) - - **Output:** + - *Individual Trend Layers:* Slope and Intercept assets generated in Step 1. + - *Additional Trend Layers:* Calculated within this script, such as Planet-NICFI visual/NIR/NDVI trends and MODIS LST Day/Night trends (Note: NICFI data access may be restricted). + - *Static/Quasi-Static Layers:* DEM-derived slope, Roads layer (rasterized). + - *Historical Fire Points:* GEE assets containing locations of past fires (e.g., `fire13_19`, `fire20_23`). + - **Method:** + 1. Loads all input layers (trends, static data). + 2. Combines these layers into a single multi-band predictor image. + 3. Resamples the predictor image to a consistent grid (e.g., 30m EPSG:3857). An asset containing this intermediate resampled image (equivalent to the original project's `inputResampled.tif`) is exported by the Python script as `FireVulnerability_InputsResampled_py`. + 4. Generates random points (labelled non-fire) and processes historical fire points (potentially categorizing them based on attributes like 'Delta T'). + 5. Samples the predictor values from the *resampled* image at the fire/non-fire point locations to create training/validation datasets. + 6. Trains a Random Forest classifier using the sampled data to learn the relationship between predictor values and fire occurrence/category. + 7. Applies the trained classifier to the entire *resampled* predictor image. + - **Output:** - Fire risk classification map (Low/High fire risk) at 30m resolution - Kappa coefficient for accuracy assessment -### 3. Fire Prediction (`TrendAnomalyPrediction.js`) +### 3. Fire Prediction using Trend Anomalies (`TrendAnomalyPrediction.js` / `TrendAnomalyPrediction.py`) + - **Goal:** Identify areas behaving abnormally compared to their long-term trends *just before* a period of interest (e.g., the start of fire season), potentially indicating heightened *near-term* fire risk. - **Inputs:** - - Trend layers - https://www.dropbox.com/scl/fi/ena1qfeqv5ppshluop8kt/inputResampled.tif?rlkey=arefwl3my7nx3z5qpknu88lsx&st=vj8cn3bd&dl=0 - - Fire event datasets (`fire13_19`, `fire20_23`) - - `pa_boundary` - - **Output:** + - Individual Trend layers (Slope/Intercept bands from Step 1). + - Study area boundary (`pa_boundary` asset). + - **Methodology:** + 1. **Load Trends:** Loads the Slope and Intercept assets generated in Step 1. + 2. **Predict Expected Conditions:** Uses the linear trend formula (`Predicted = Slope * Time_Difference + Intercept`) to estimate the expected value for each indicator at a specific near-future date (e.g., March 1st), based on the trend's reference start date. + 3. **Load Observed Conditions:** Loads and processes the most recent available observational data *before* the prediction date (e.g., Landsat, SMAP, ERA5 for the preceding month; CHIRPS sum for the preceding year). + 4. **Calculate Anomaly:** Computes the difference: `Anomaly = Observed - Predicted`. + 5. **Identify Hotspots:** Applies thresholds to specific anomaly bands (e.g., `ST_B10_Anomaly > 3.2`, `ndmi_Anomaly < -0.15`) to flag areas where conditions deviate significantly from the trend in a way suggesting increased fire risk (e.g., hotter or drier than expected). + - **Outputs:** + - *Full Anomaly Image:* GEE asset containing all calculated anomaly bands (e.g., `TrendAnomaly_py`). Pixel values represent the difference between observed and predicted conditions. + - *Hotspot Images:* Derived boolean/masked images showing areas exceeding specific anomaly thresholds (e.g., `TrendAnomaly_STB10_Hotspot_py`). - Anomaly map comparing trend layers with current conditions + - **Interpretation:** Hotspots indicate areas where recent conditions are unusually conducive to fire compared to that location's historical trend for that time of year. This provides a dynamic, short-term risk indicator, ideally interpreted alongside the longer-term vulnerability map from Step 2. + +## Potential Improvements & Next Steps +* **Trend Model:** Explore non-linear trend models (e.g., harmonic regression) if significant seasonality or non-linear changes are present, potentially providing a more accurate baseline for anomaly calculation. +* **Data Gaps:** Investigate methods to fill gaps in input data (especially cloud-related gaps in Landsat) using techniques like temporal interpolation or data fusion to allow for trend calculation in more areas. +* **Vulnerability Model Inputs:** Evaluate the impact of different input features (e.g., including/excluding NICFI/MODIS LST based on availability/quality) on the vulnerability model performance. +* **Training Data Strategy:** Refine the generation of non-fire points (e.g., using buffers, stratification) and explore different fire point categorization schemes for training the vulnerability model. +* **Anomaly Thresholds:** Validate and potentially calibrate the anomaly thresholds used for hotspot detection against historical fire data or field observations to improve their local accuracy and relevance. +* **Temporal Resolution:** Incorporate more frequent or near-real-time data sources if available to reduce the lag between observation and prediction in the anomaly step. +* **Model Integration:** Combine the trend anomaly results with the vulnerability map to create a more comprehensive risk assessment (e.g., prioritizing areas that are both historically vulnerable *and* currently showing high-risk anomalies). -This workflow enables proactive fire risk management by identifying vulnerable areas based on historical patterns and predictive modeling. +This workflow enables proactive fire risk management by identifying vulnerable areas based on historical patterns and predictive modeling using trend anomalies. diff --git a/TrendAnomalyPrediction.py b/TrendAnomalyPrediction.py new file mode 100644 index 0000000..e9f2e65 --- /dev/null +++ b/TrendAnomalyPrediction.py @@ -0,0 +1,711 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" +TrendAnomalyPrediction.py: Python implementation of TrendAnomalyPrediction.js using Earth Engine Python API. + +This script calculates trend anomalies for various indices based on pre-computed trends +and recent observations. + +Steps: +1. Load pre-computed trend layers (Slope and Intercept for various indices). +2. Load the study area boundary. +3. Define prediction date and reference start dates for trends. +4. Calculate predicted index values for the prediction date. +5. Load actual observed data ('present data') for the period preceding the prediction date. +6. Calculate the anomaly (Present - Predicted). +7. Export the anomaly results. +""" + +import ee +import os +import datetime +import geopandas as gpd +from shapely.geometry import Polygon + +# ============================================================================== +# Helper Functions (Adapted from TrendFire.py) +# ============================================================================== + +def initialize_ee(project_id='ee-crop-health-telangana'): # Use the verified project ID + """Initializes the Earth Engine API.""" + try: + # Attempt authentication. Might prompt user if credentials are not found. + ee.Authenticate() # Often needed only once per session/machine + + # Initialize with the specified project ID. + ee.Initialize(project=project_id, opt_url='https://earthengine-highvolume.googleapis.com') # Use high volume endpoint + + print(f"Earth Engine API initialized successfully for project: {project_id}") + except ee.EEException as e: + print(f"Error initializing Earth Engine API for project {project_id}: {e}") + print("Please ensure:") + print(" 1. You have authenticated (e.g., via `gcloud auth application-default login`).") + print(f" 2. The project ID '{project_id}' is correct.") + print(" 3. The Earth Engine API is enabled for this project in Google Cloud Console.") + print(" 4. The account used for authentication has access to this project.") + raise # Re-raise the exception to stop execution if initialization fails + except Exception as e: + # Catch other potential errors during initialization + print(f"An unexpected error occurred during Earth Engine initialization: {e}") + raise # Ensure execution stops on unexpected error + +def get_goa_boundary(asset_id='users/jonasnothnagel/pa_boundary'): + """ + Get the boundary of the study area directly from the GEE asset. + Returns an ee.Geometry object. + """ + try: + print(f"Loading study area boundary from GEE asset: {asset_id}...") + goa_fc = ee.FeatureCollection(asset_id) + + # Ensure the collection is not empty + if goa_fc.size().getInfo() == 0: + print(f"Error: Asset {asset_id} is empty or inaccessible.") + return None + + # Get the geometry, dissolve potentially multi-part features + goa_geometry = goa_fc.geometry().dissolve() + + print("Successfully loaded boundary from GEE asset.") + return goa_geometry + + except ee.EEException as e: + print(f"Error loading boundary from GEE asset {asset_id}: {e}") + print("Please ensure the asset exists and you have read permissions.") + return None + except Exception as e: + print(f"An unexpected error occurred loading the boundary asset: {e}") + return None + +def export_to_asset(image, asset_id, region, description=None, scale=30, crs='EPSG:3857'): + """Exports an image to a Google Earth Engine asset, deleting if exists.""" + if description is None: + description = asset_id.split('/')[-1] + + # Check and delete existing asset + try: + asset_info = ee.data.getInfo(asset_id) + if asset_info: + print(f"Asset {asset_id} already exists. Deleting...") + ee.data.deleteAsset(asset_id) + print(f"Asset {asset_id} deleted.") + except ee.EEException as e: + if 'not found' in str(e).lower(): + print(f"Asset {asset_id} not found. Proceeding with export.") + else: + print(f"Error checking/deleting asset {asset_id}: {e}. Proceeding...") + except Exception as e: + print(f"Unexpected error checking/deleting asset {asset_id}: {e}. Proceeding...") + + print(f"Starting export task to Asset: {description} (ID: {asset_id})") + task = ee.batch.Export.image.toAsset( + image=image.toFloat(), # Ensure float type for export + description=description, + assetId=asset_id, + region=region, + scale=scale, + crs=crs, + maxPixels=1e13 + ) + task.start() + print(f"Task started (id: {task.id}). Check GEE Tasks.") + return task + +# Function to debug the shapefile (Optional but good practice) +def debug_shapefile(boundary_path): + """ + Debug function to check shapefile contents and geometry validity. + """ + try: + print("\nDebugging shapefile...") + gdf = gpd.read_file(boundary_path) + print(f"\nShapefile contains {len(gdf)} features") + print("\nFirst few rows of the data:") + print(gdf.head()) + print("\nGeometry type:", gdf.geometry.type.unique()) + print("\nCRS:", gdf.crs) + + # Check if geometries are valid + invalid_geoms = gdf[~gdf.geometry.is_valid] + if len(invalid_geoms) > 0: + print("\nWarning: Found invalid geometries!") + print("Number of invalid geometries:", len(invalid_geoms)) + print("\nInvalid geometries:") + print(invalid_geoms) + + return gdf + except Exception as e: + print(f"Error debugging shapefile: {e}") + return None + +# Function to mask clouds in Landsat 8 imagery +def maskL8sr(image): + """ + Mask clouds and scale pixel values for Landsat 8 SR imagery. + Matches the JavaScript implementation. + """ + # Bits 0-4 are Fill, Dilated Cloud, Cirrus, Cloud, Cloud Shadow. + qaMask = image.select('QA_PIXEL').bitwiseAnd(int('11111', 2)).eq(0) + saturationMask = image.select('QA_RADSAT').eq(0) + + # Scale the optical bands + optical_bands = image.select('SR_B.').multiply(0.0000275).add(-0.2) + + # Scale the thermal bands + thermal_bands = image.select('ST_B.*').multiply(0.00341802).add(149.0) + + # Return the masked and scaled image, applying both masks + return image.addBands(optical_bands, None, True) \ + .addBands(thermal_bands, None, True) \ + .updateMask(qaMask) \ + .updateMask(saturationMask) + +# Function to calculate spectral indices and add them as bands +def addIndices(image): + """ + Calculate various spectral indices and add them as bands to the image. + """ + # NDVI (Normalized Difference Vegetation Index) + ndvi = image.normalizedDifference(['SR_B5', 'SR_B4']).rename('ndvi') + + # EVI (Enhanced Vegetation Index) + evi = image.expression( + '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', + { + 'NIR': image.select('SR_B5'), + 'RED': image.select('SR_B4'), + 'BLUE': image.select('SR_B2') + } + ).rename('evi') + + # MSAVI (Modified Soil Adjusted Vegetation Index) + msavi = image.expression( + '(2 * NIR + 1 - sqrt((2 * NIR + 1) * (2 * NIR + 1) - 8 * (NIR - RED))) / 2', + { + 'NIR': image.select('SR_B5'), + 'RED': image.select('SR_B4') + } + ).rename('msavi') + + # MIRBI (Mid-Infrared Burn Index) + mirbi = image.expression( + '10 * SWIR2 - 9.8 * SWIR1 + 2', + { + 'SWIR1': image.select('SR_B6'), + 'SWIR2': image.select('SR_B7') + } + ).rename('mirbi') + + # NDMI (Normalized Difference Moisture Index) + ndmi = image.normalizedDifference(['SR_B5', 'SR_B6']).rename('ndmi') + + # NDFI (Normalized Difference Fraction Index) - Uses ST_B10 and SR_B6 like JS + ndfi = image.normalizedDifference(['ST_B10', 'SR_B6']).rename('ndfi') + + # NBR (Normalized Burn Ratio) + nbr = image.normalizedDifference(['SR_B5', 'SR_B7']).rename('nbr') + + # NBR2 (Normalized Burn Ratio 2) + nbr2 = image.normalizedDifference(['SR_B6', 'SR_B7']).rename('nbr2') + + # BSI (Bare Soil Index) + bsi = image.expression( + '((SWIR1 + RED) - (NIR + BLUE)) / ((SWIR1 + RED) + (NIR + BLUE))', + { + 'SWIR1': image.select('SR_B6'), + 'RED': image.select('SR_B4'), + 'NIR': image.select('SR_B5'), + 'BLUE': image.select('SR_B2') + } + ).rename('bsi') + + # Add all indices as bands + return image.addBands([ndvi, evi, msavi, mirbi, ndmi, ndfi, nbr, nbr2, bsi]) + + +# Function to calculate SMI using SWIR bands (requires pre-calculated min/max) +def addSMI_local(image, swir_min, swir_max): + """Calculates SMI, requires swir min/max for the specific collection.""" + # Ensure swir_min and swir_max are ee.Number objects + swir_min = ee.Number(swir_min) + swir_max = ee.Number(swir_max) + # Avoid division by zero or non-numeric results if swir_max <= swir_min + smi = image.select('SR_B7').subtract(swir_min) \ + .divide(swir_max.subtract(swir_min).max(ee.Number(1e-9))) \ + .multiply(-1).add(1).rename('smi') + return image.addBands(smi) + +# Function to calculate vapor pressure (for RH calculation) +def calcVaporPressure(temp_k): + """ Calculates vapor pressure from temperature in Kelvin using Clausius-Clapeyron approx. """ + # Convert Kelvin to Celsius for the formula + temp_c = temp_k.subtract(273.15) + # Formula parameters from the JS script (note 19.67, standard is often 17.67) + # Ensure calculations are done per pixel + denom = temp_c.add(243.5) + num = temp_c.multiply(19.67) + exponent = num.divide(denom).exp() # e^(...) + return exponent.multiply(6.112) #Multiply by saturation vapor pressure at 0°C (in hPa or mbar) + +# ============================================================================== +# Main Script Logic +# ============================================================================== + +def main(): + """Main script execution.""" + # --- Initialization (Moved to the top) --- + PROJECT_ID = 'ee-crop-health-telangana' # Or get from environment variable + initialize_ee(PROJECT_ID) + + # --- Configuration --- + BOUNDARY_ASSET_ID = 'users/jonasnothnagel/pa_boundary' + OUTPUT_ASSET_BASE = 'users/jonasnothnagel/' # Base path for output assets + + # Now create GEE objects after initialization + PREDICTION_DATE = ee.Date('2023-03-01') + PRESENT_START_DATE = '2023-02-01' # For LS, SM, RH + PRESENT_END_DATE = '2023-02-28' # For LS, SM, RH + RAIN_YEAR_START = '2022-01-01' # CHIRPS sum year start + RAIN_YEAR_END = '2022-12-31' # CHIRPS sum year end + + # Trend reference start dates (match TrendFire.js/py logic) + TREND_REF_DATES = { + 'landsat': ee.Date('2013-03-20'), + 'rain': ee.Date('1982-01-01'), + 'sm': ee.Date('2015-04-01'), + 'rh': ee.Date('1980-01-01') + } + + # --- Load Boundary (after init) --- + boundary = get_goa_boundary(BOUNDARY_ASSET_ID) + if boundary is None: + print("Exiting: Could not load boundary.") + return + + # --- Processing Steps --- + # 1. Load Original Trend Assets + original_trends = load_original_trend_assets() + if original_trends is None: + print("Exiting: Could not load original trend assets.") + return + # print("Placeholder: Skipping load_original_trend_assets()") + # original_trends = None # Temporary + + # 2. Calculate Predicted Values + predicted_image = calculate_predicted_values(original_trends, PREDICTION_DATE, TREND_REF_DATES) + if predicted_image is None: + print("Exiting: Could not calculate predicted values.") + return + # print("Placeholder: Skipping calculate_predicted_values()") + # predicted_image = None # Temporary + + # 3. Get Present Data + present_image = get_present_data(boundary, PRESENT_START_DATE, PRESENT_END_DATE, RAIN_YEAR_START, RAIN_YEAR_END) + if present_image is None: + print("Exiting: Could not get present data.") + return + # print("Placeholder: Skipping get_present_data()") + # present_image = None # Temporary + + # 4. Calculate Anomaly (Requires present_image and predicted_image) + if present_image and predicted_image: + anomaly_image = calculate_anomaly(present_image, predicted_image) + print("Anomaly image calculated.") + # print(anomaly_image.bandNames().getInfo()) # Verify band names + + # --- Export Full Anomaly Results --- + anomaly_asset_id = OUTPUT_ASSET_BASE + 'TrendAnomaly_py' + export_to_asset( + image=anomaly_image, + asset_id=anomaly_asset_id, + region=boundary, + description='Trend_Anomaly_Python', + scale=30 + ) + + # --- Calculate and Export Specific Hotspots (Matching JS Drive Exports) --- + print("Calculating and exporting specific hotspots...") + try: + # ST_B10 Hotspot (Thermal Anomaly) + stb10_hotspot = anomaly_image.select('ST_B10_Anomaly').gt(3.2) # Pixels significantly hotter than predicted + # Masking non-hotspot areas (optional, makes visualization cleaner) + # stb10_hotspot = stb10_hotspot.selfMask() + stb10_asset_id = OUTPUT_ASSET_BASE + 'TrendAnomaly_STB10_Hotspot_py' + export_to_asset( + image=stb10_hotspot.unmask(0).toFloat(), # Export boolean as 0/1 float + asset_id=stb10_asset_id, + region=boundary, + description='Hotspot_STB10_py', + scale=30 + ) + + # NDMI Hotspot (Moisture Anomaly) + ndmi_hotspot = anomaly_image.select('ndmi_Anomaly').lt(-0.15) # Pixels significantly drier than predicted + # ndmi_hotspot = ndmi_hotspot.selfMask() + ndmi_asset_id = OUTPUT_ASSET_BASE + 'TrendAnomaly_NDMI_Hotspot_py' + export_to_asset( + image=ndmi_hotspot.unmask(0).toFloat(), # Export boolean as 0/1 float + asset_id=ndmi_asset_id, + region=boundary, + description='Hotspot_NDMI_py', + scale=30 + ) + print("Hotspot export tasks started.") + + except ee.EEException as e: + print(f"Could not calculate or export hotspots: {e}") + # Check if specific anomaly bands exist in anomaly_image + print("Available anomaly bands:", anomaly_image.bandNames().getInfo()) + except Exception as e: + print(f"Unexpected error during hotspot processing: {e}") + + else: + print("Skipping anomaly calculation and export due to missing inputs (likely placeholder functions)." ) # Updated message + + print("\nScript finished. Monitor GEE tasks for export status.") + +# --- Trend Anomaly Specific Functions --- + +def load_original_trend_assets(base_path='users/jonasnothnagel/'): + """ + Loads the individual trend assets generated by the original TrendFire.js script + (assumed to be under the user's GEE path) and merges them. + Returns a single ee.Image with all trend bands (Slope and Intercept). + """ + print(f"Loading original trend assets from base path: {base_path}...") + + # Define asset suffixes and index names based on TrendFire.js output + landsat_indices = ['ndvi', 'evi', 'mirbi', 'ndfi', 'bsi', 'ndmi', 'nbr', 'nbr2', 'msavi', 'smi', 'ST_B10'] + landsat_asset_prefix = 'Trend2023_' # Corrected from suffix to prefix + rain_asset_id_part = 'Trend2022_rain_new' + sm_asset_id_part = 'Trend2023_SM_new' + rh_asset_id_part = 'Trend2024_RH_new' + + all_trend_bands = ee.Image().toFloat() # Start with an empty image, cast to float early + asset_id = '' # Initialize asset_id for error message context + + try: + # Load Landsat index trends + for index in landsat_indices: + asset_id = f"{base_path}{landsat_asset_prefix}{index}" + print(f" Loading Landsat trend: {asset_id}") + trend_img = ee.Image(asset_id) + # Expecting bands: index_Slope, index_Intercept + all_trend_bands = all_trend_bands.addBands(trend_img) + + # Load Rain trend + asset_id = f"{base_path}{rain_asset_id_part}" + print(f" Loading Rain trend: {asset_id}") + rain_trend = ee.Image(asset_id) # Bands: rain_Slope, rain_Intercept + all_trend_bands = all_trend_bands.addBands(rain_trend) + + # Load SM trend + asset_id = f"{base_path}{sm_asset_id_part}" + print(f" Loading SM trend: {asset_id}") + sm_trend = ee.Image(asset_id) # Bands: sm_surface_Slope, sm_surface_Intercept + # Ensure band name consistency if different from TrendFire.py + # sm_trend = sm_trend.rename(['sm_Slope', 'sm_Intercept']) # Example rename if needed + all_trend_bands = all_trend_bands.addBands(sm_trend) + + # Load RH trend + asset_id = f"{base_path}{rh_asset_id_part}" + print(f" Loading RH trend: {asset_id}") + rh_trend = ee.Image(asset_id) # Bands: rh_Slope, rh_Intercept + all_trend_bands = all_trend_bands.addBands(rh_trend) + + # Remove the empty initial band if necessary (usually not needed with addBands) + # band_names = all_trend_bands.bandNames() + # if band_names.length().gt(0) and band_names.get(0).match('^_*'): # Check if first band is empty/default + # all_trend_bands = all_trend_bands.select(band_names.slice(1)) + + print("Successfully loaded and merged all original trend assets.") + # Verify band names (optional) + # print("Loaded trend bands:", all_trend_bands.bandNames().getInfo()) + return all_trend_bands + + except ee.EEException as e: + print(f"Error loading GEE asset during trend loading: {e}") + print(f"Please ensure asset '{asset_id}' exists and you have permissions.") + return None + except Exception as e: + print(f"An unexpected error occurred loading trend assets: {e}") + return None + +def calculate_predicted_values(trend_image, prediction_date, ref_dates): + """ + Calculates the predicted values for each index based on trends. + + Args: + trend_image: ee.Image with bands like 'index_Slope', 'index_Intercept'. + prediction_date: ee.Date object for the prediction target date. + ref_dates: Dictionary mapping dataset type ('landsat', 'rain', 'sm', 'rh') + to its trend reference start ee.Date. + + Returns: + ee.Image with predicted values for each index (bands named 'index'). + """ + print(f"Calculating predicted values for {prediction_date.format('YYYY-MM-dd').getInfo()}...") + + try: + # Define the base index names and their corresponding dataset types + # Note: SM index from JS/Python TrendFire is 'sm_surface', RH is 'RH' + index_mapping = { + 'ndvi': 'landsat', 'evi': 'landsat', 'mirbi': 'landsat', 'ndfi': 'landsat', + 'bsi': 'landsat', 'ndmi': 'landsat', 'nbr': 'landsat', 'nbr2': 'landsat', + 'msavi': 'landsat', 'smi': 'landsat', 'ST_B10': 'landsat', + 'rain': 'rain', + 'sm_surface': 'sm', # Match SM band name from TrendFire + 'rh': 'rh' # Match RH band name from TrendFire + } + + predicted_bands_list = [] + + for index, dataset_type in index_mapping.items(): + print(f" Predicting for index: {index} (type: {dataset_type})") + + # Get the specific reference date for this dataset type + ref_date = ref_dates.get(dataset_type) + if not ref_date: + print(f" Error: Reference date not found for dataset type '{dataset_type}'. Skipping index '{index}'.") + continue + + # Calculate time difference in years + time_diff = prediction_date.difference(ref_date, 'year') + + # Construct band names for slope and intercept + slope_band = f'{index}_Slope' + intercept_band = f'{index}_Intercept' + + # Check if bands exist in the input image + if slope_band not in trend_image.bandNames().getInfo() or \ + intercept_band not in trend_image.bandNames().getInfo(): + print(f" Error: Bands '{slope_band}' or '{intercept_band}' not found in trend image. Skipping index '{index}'.") + continue + + # Select bands + slope = trend_image.select(slope_band) + intercept = trend_image.select(intercept_band) + + # Calculate predicted value: predicted = slope * time_diff + intercept + predicted = slope.multiply(time_diff).add(intercept) + + # Rename the predicted band to the simple index name + predicted = predicted.rename(index) + + predicted_bands_list.append(predicted) + + # Check if any bands were processed + if not predicted_bands_list: + print("Error: No predicted bands were generated. Check input trend image and band names.") + return None + + # Combine all predicted bands into a single image + predicted_image = ee.ImageCollection(predicted_bands_list).toBands() + + # The toBands() function creates names like '0_ndvi', '1_evi'. We need to rename them back. + original_band_names = [img.bandNames().get(0) for img in predicted_bands_list] + predicted_image = predicted_image.rename(original_band_names) + + print("Predicted values calculated successfully.") + # print("Predicted bands:", predicted_image.bandNames().getInfo()) # Optional verification + return predicted_image + + except ee.EEException as e: + print(f"GEE error during predicted value calculation: {e}") + return None + except Exception as e: + print(f"Unexpected error during predicted value calculation: {e}") + return None + +def get_present_data(boundary, present_start, present_end, rain_year_start, rain_year_end): + """ + Loads and prepares the 'present' observational data for the period before prediction. + + Args: + boundary: ee.Geometry for clipping. + present_start: Start date (YYYY-MM-DD) for Landsat, SMAP, ERA5. + present_end: End date (YYYY-MM-DD) for Landsat, SMAP, ERA5. + rain_year_start: Start date (YYYY-MM-DD) for the annual rainfall sum year. + rain_year_end: End date (YYYY-MM-DD) for the annual rainfall sum year. + + Returns: + ee.Image with observed values (bands named 'index'). + """ + print(f"Loading present data ({present_start} to {present_end}, Rain year: {rain_year_start} to {rain_year_end})...") + + try: + # 1. Landsat Present (Feb 2023 Mosaic) + print(" Processing present-day Landsat...") + ls_present_col = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2') \ + .filterDate(present_start, present_end) \ + .filterBounds(boundary) \ + .map(maskL8sr) \ + .map(lambda img: img.clip(boundary)) \ + .map(addIndices) + + # Calculate SWIR min/max for *this specific collection* for SMI + # Handle potential empty collection after filtering/masking + collection_size = ls_present_col.size().getInfo() + present_ls_mosaic = None + if collection_size > 0: + swir_stats_present = ls_present_col.mean().select('SR_B7').reduceRegion( + reducer=ee.Reducer.minMax(), + geometry=boundary, + scale=30, + maxPixels=1e9 # Use lower maxPixels for reduceRegion if needed + ) + # Handle potential nulls if band doesn't exist or all pixels masked + swir_min_present = ee.Number(ee.Algorithms.If(swir_stats_present.contains('SR_B7_min'), swir_stats_present.get('SR_B7_min'), 0)) + swir_max_present = ee.Number(ee.Algorithms.If(swir_stats_present.contains('SR_B7_max'), swir_stats_present.get('SR_B7_max'), 1)) # Avoid divide by zero + + ls_present_col_smi = ls_present_col.map(lambda img: addSMI_local(img, swir_min_present, swir_max_present)) + + # Select relevant bands and create mosaic + present_ls_bands = ['smi', 'ST_B10', 'ndvi', 'evi', 'msavi', 'mirbi', 'ndmi', 'ndfi', 'nbr', 'nbr2', 'bsi'] + present_ls_mosaic = ls_present_col_smi.select(present_ls_bands).mosaic() + print(" Landsat mosaic created.") + else: + print(" Warning: No valid Landsat images found for the present period. Landsat bands will be missing.") + # Create a placeholder image if needed, or handle downstream + + # 2. ERA5 RH Present (Feb 2023 Mean) + print(" Processing present-day ERA5 RH...") + era5_present_col = ee.ImageCollection("ECMWF/ERA5_LAND/MONTHLY_AGGR") \ + .filterDate(present_start, present_end) \ + .filterBounds(boundary) \ + .map(lambda img: img.clip(boundary)) + + def calculateRH(image): + dewPoint_k = image.select('dewpoint_temperature_2m') + temp_k = image.select('temperature_2m') + eT = calcVaporPressure(temp_k) + eTd = calcVaporPressure(dewPoint_k) + # Avoid division by zero if eT is 0 and clamp RH + rh = eTd.divide(eT.max(1e-9)).multiply(100).max(0).min(100) + return rh.rename('rh').set('system:time_start', image.get('system:time_start')) + + rh_collection_present = era5_present_col.map(calculateRH) + # Check if collection is empty before calculating mean + present_rh = None + if rh_collection_present.size().getInfo() > 0: + present_rh = rh_collection_present.mean() # Use mean for monthly agg + print(" ERA5 RH calculated (mean).") + else: + print(" Warning: No ERA5 data found for the present period. RH band will be missing.") + + # 3. SMAP Present (Feb 2023 Mosaic) + print(" Processing present-day SMAP...") + smap_present_col = ee.ImageCollection('NASA/SMAP/SPL3SMP_E/005') \ + .filterDate(present_start, present_end) \ + .filterBounds(boundary) \ + .map(lambda img: img.clip(boundary)) \ + .select(['soil_moisture_am']) + + present_sm = None + if smap_present_col.size().getInfo() > 0: + present_sm = smap_present_col.mosaic().rename('sm_surface') # Rename to match trend band name + print(" SMAP mosaic created.") + else: + print(" Warning: No SMAP data found for the present period. SM band will be missing.") + + # 4. CHIRPS Rain Present (Sum for 2022) + print(" Processing present-day CHIRPS Rain (2022 Sum)...") + chirps_present_col = ee.ImageCollection('UCSB-CHG/CHIRPS/DAILY') \ + .filterDate(rain_year_start, rain_year_end) \ + .filterBounds(boundary) + + present_rain = None + if chirps_present_col.size().getInfo() > 0: + # Calculate sum for the year 2022 + yearly_sum_2022 = chirps_present_col.sum().clip(boundary).rename('rain') + present_rain = yearly_sum_2022 + print(" CHIRPS Rain sum calculated.") + else: + print(" Warning: No CHIRPS data found for the rain year. Rain band will be missing.") + + # Combine all present-day layers + print(" Combining present data layers...") + # Start with an empty image and add bands conditionally + present_all = ee.Image().toFloat() + if present_ls_mosaic is not None: + present_all = present_all.addBands(present_ls_mosaic) + if present_rain is not None: + present_all = present_all.addBands(present_rain) + if present_rh is not None: + present_all = present_all.addBands(present_rh) + if present_sm is not None: + present_all = present_all.addBands(present_sm) + + # Check if any bands were added + if not present_all.bandNames().getInfo(): + print("Error: No present data bands could be generated.") + return None + + print("Present-day data loaded and processed.") + # Select bands in the same order as predicted_image expects for calculate_anomaly + # This order comes from the `calculate_predicted_values` function's index_mapping + final_band_order = [ + 'ndvi', 'evi', 'mirbi', 'ndfi', 'bsi', 'ndmi', 'nbr', 'nbr2', + 'msavi', 'smi', 'ST_B10', 'rain', 'sm_surface', 'rh' + ] + + # Select only the bands that were successfully created + available_bands = present_all.bandNames() + bands_to_select = [b for b in final_band_order if b in available_bands.getInfo()] + + if not bands_to_select: + print("Error: No matching bands found between predicted and present images.") + return None + + present_all = present_all.select(bands_to_select) + # print("Final present bands:", present_all.bandNames().getInfo()) # Optional verification + return present_all + + except ee.EEException as e: + print(f"GEE error during present data retrieval: {e}") + return None + except Exception as e: + print(f"Unexpected error during present data retrieval: {e}") + return None + +def calculate_anomaly(present_image, predicted_image): + """ + Calculates the anomaly image (Present - Predicted). + + Args: + present_image: ee.Image with observed values ('index' bands). + predicted_image: ee.Image with predicted values ('index' bands). + + Returns: + ee.Image with anomaly values ('index_Anomaly' bands). + """ + print("Calculating anomaly image...") + # Ensure band names match for subtraction + present_bands = present_image.bandNames() + predicted_bands = predicted_image.bandNames() + + # Assuming predicted_image has the target band names ('ndvi', 'evi', etc.) + # Select corresponding bands from present_image if needed + present_image_aligned = present_image.select(predicted_bands) + + anomaly = present_image_aligned.subtract(predicted_image) + + # Rename bands to include _Anomaly suffix + new_band_names = predicted_bands.map(lambda b: ee.String(b).cat('_Anomaly')) + anomaly = anomaly.rename(new_band_names) + + return anomaly + +# --- Main Execution --- + +if __name__ == "__main__": + # Add dependency check if desired + try: + import geopandas + import shapely + except ImportError as e: + print(f"Missing dependency: {e}") + print("Please install required libraries: pip install geopandas shapely") + else: + main() \ No newline at end of file diff --git a/TrendFire.py b/TrendFire.py new file mode 100644 index 0000000..ecb3530 --- /dev/null +++ b/TrendFire.py @@ -0,0 +1,686 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" +TrendFire.py: Python implementation of TrendFire.js using Earth Engine Python API. +This script calculates various vegetation, burn, and climate trends for a study area in Goa, India. + +The script performs the following steps: +1. Processes Landsat 8 imagery for various spectral indices (NDVI, EVI, MSAVI, etc.) +2. Calculates long-term trends using linear regression for each index +3. Processes CHIRPS precipitation data and calculates rainfall trends +4. Processes SMAP soil moisture data and calculates soil moisture trends +5. Processes ERA5 relative humidity data and calculates humidity trends +6. Exports trend layers as GEE assets and local GeoTIFF files + +Equivalent to the TrendFire.js script in the original implementation. +""" + +import ee +import os +import datetime +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import geopandas as gpd +from tqdm import tqdm +from shapely.geometry import Polygon +import ee.data # Import the data module + +# Initialize the Earth Engine API +def initialize_ee(project_id='ee-crop-health-telangana'): + try: + # Attempt authentication. Might prompt user if credentials are not found. + ee.Authenticate() + + # Initialize with the specified project ID. + ee.Initialize(project=project_id) + + print(f"Earth Engine API initialized successfully for project: {project_id}") + except ee.EEException as e: + print(f"Error initializing Earth Engine API for project {project_id}: {e}") + print("Please ensure:") + print(" 1. You have authenticated with `ee.Authenticate()`.") + print(f" 2. The project ID '{project_id}' is correct.") + print(" 3. The Earth Engine API is enabled for this project in Google Cloud Console.") + print(" 4. The account used for authentication has access to this project.") + raise # Re-raise the exception to stop execution if initialization fails + except Exception as e: + # Catch other potential errors during initialization + print(f"An unexpected error occurred during Earth Engine initialization: {e}") + raise + +# Function to debug the shapefile +def debug_shapefile(boundary_path): + """ + Debug function to check shapefile contents and geometry validity. + """ + try: + print("\nDebugging shapefile...") + gdf = gpd.read_file(boundary_path) + print(f"\nShapefile contains {len(gdf)} features") + print("\nFirst few rows of the data:") + print(gdf.head()) + print("\nGeometry type:", gdf.geometry.type.unique()) + print("\nCRS:", gdf.crs) + + # Check if geometries are valid + invalid_geoms = gdf[~gdf.geometry.is_valid] + if len(invalid_geoms) > 0: + print("\nWarning: Found invalid geometries!") + print("Number of invalid geometries:", len(invalid_geoms)) + print("\nInvalid geometries:") + print(invalid_geoms) + + return gdf + except Exception as e: + print(f"Error debugging shapefile: {e}") + return None + +# Define the Goa study area boundary +def get_goa_boundary(): + """ + Get the boundary of the study area directly from the GEE asset. + Returns an ee.Geometry object. + """ + try: + asset_id = 'users/jonasnothnagel/pa_boundary' + print(f"Loading study area boundary from GEE asset: {asset_id}...") + goa_fc = ee.FeatureCollection(asset_id) + + # Ensure the collection is not empty + if goa_fc.size().getInfo() == 0: + print(f"Error: Asset {asset_id} is empty or inaccessible.") + return None + + # Get the geometry of the first feature (assuming it's a single polygon feature) + # Use .geometry() to simplify the FeatureCollection to a single Geometry + # Use .dissolve() first to merge geometries if it might be a multi-part feature collection + goa_geometry = goa_fc.geometry().dissolve() + + # Optional: Check geometry validity (can be computationally intensive) + # is_valid = goa_geometry.isValid().getInfo() + # if not is_valid: + # print(f"Warning: Geometry from asset {asset_id} may not be valid according to GEE.") + + print("Successfully loaded boundary from GEE asset.") + return goa_geometry + + except ee.EEException as e: + print(f"Error loading boundary from GEE asset {asset_id}: {e}") + print("Please ensure the asset exists and you have read permissions.") + return None + except Exception as e: + # Catch other potential errors + print(f"An unexpected error occurred loading the boundary asset: {e}") + return None + +# Function to mask clouds in Landsat 8 imagery +def maskL8sr(image): + """ + Mask clouds and scale pixel values for Landsat 8 SR imagery. + Matches the JavaScript implementation. + """ + # Bits 0-4 are Fill, Dilated Cloud, Cirrus, Cloud, Cloud Shadow. + qaMask = image.select('QA_PIXEL').bitwiseAnd(int('11111', 2)).eq(0) + saturationMask = image.select('QA_RADSAT').eq(0) + + # Scale the optical bands + optical_bands = image.select('SR_B.').multiply(0.0000275).add(-0.2) + + # Scale the thermal bands + thermal_bands = image.select('ST_B.*').multiply(0.00341802).add(149.0) + + # Return the masked and scaled image, applying both masks + return image.addBands(optical_bands, None, True) \ + .addBands(thermal_bands, None, True) \ + .updateMask(qaMask) \ + .updateMask(saturationMask) + +# Function to calculate spectral indices and add them as bands +def addIndices(image): + """ + Calculate various spectral indices and add them as bands to the image. + """ + # NDVI (Normalized Difference Vegetation Index) + ndvi = image.normalizedDifference(['SR_B5', 'SR_B4']).rename('ndvi') + + # EVI (Enhanced Vegetation Index) + evi = image.expression( + '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', + { + 'NIR': image.select('SR_B5'), + 'RED': image.select('SR_B4'), + 'BLUE': image.select('SR_B2') + } + ).rename('evi') + + # MSAVI (Modified Soil Adjusted Vegetation Index) + msavi = image.expression( + '(2 * NIR + 1 - sqrt((2 * NIR + 1) * (2 * NIR + 1) - 8 * (NIR - RED))) / 2', + { + 'NIR': image.select('SR_B5'), + 'RED': image.select('SR_B4') + } + ).rename('msavi') + + # MIRBI (Mid-Infrared Burn Index) + mirbi = image.expression( + '10 * SWIR2 - 9.8 * SWIR1 + 2', + { + 'SWIR1': image.select('SR_B6'), + 'SWIR2': image.select('SR_B7') + } + ).rename('mirbi') + + # NDMI (Normalized Difference Moisture Index) + ndmi = image.normalizedDifference(['SR_B5', 'SR_B6']).rename('ndmi') + + # NDFI (Normalized Difference Fraction Index) - Corrected formula + ndfi = image.normalizedDifference(['ST_B10', 'SR_B6']).rename('ndfi') + + # NBR (Normalized Burn Ratio) + nbr = image.normalizedDifference(['SR_B5', 'SR_B7']).rename('nbr') + + # NBR2 (Normalized Burn Ratio 2) + nbr2 = image.normalizedDifference(['SR_B6', 'SR_B7']).rename('nbr2') + + # BSI (Bare Soil Index) + bsi = image.expression( + '((SWIR1 + RED) - (NIR + BLUE)) / ((SWIR1 + RED) + (NIR + BLUE))', + { + 'SWIR1': image.select('SR_B6'), + 'RED': image.select('SR_B4'), + 'NIR': image.select('SR_B5'), + 'BLUE': image.select('SR_B2') + } + ).rename('bsi') + + # Add all indices as bands + return image.addBands([ndvi, evi, msavi, mirbi, ndmi, ndfi, nbr, nbr2, bsi]) + +# Function to calculate SMI (Soil Moisture Index) +def calculateSMI(image): + """ + Calculate Soil Moisture Index (SMI) from Landsat data. + """ + Ts = image.select('ST_B10') + ndvi = image.select('ndvi') + + # Apply the SMI calculation + smi = image.expression( + '(Ts_max - Ts) / (Ts_max - Ts_min)', + { + 'Ts': Ts, + 'Ts_max': Ts.reduceRegion( + reducer=ee.Reducer.max(), + geometry=image.geometry(), + scale=30, + maxPixels=1e9 + ).get('ST_B10'), + 'Ts_min': Ts.reduceRegion( + reducer=ee.Reducer.min(), + geometry=image.geometry(), + scale=30, + maxPixels=1e9 + ).get('ST_B10') + } + ).rename('smi') + + return image.addBands(smi) + +# Main function to process Landsat 8 data and calculate trends +def process_landsat_trends(goa, start_date='2013-03-20', end_date='2023-02-28'): + """ + Process Landsat 8 imagery, calculate vegetation indices and trends. + """ + print("Processing Landsat 8 data and calculating trends...") + + # Define the outlier date + outlier_date = ee.Date('2016-06-22') + + # Load Landsat 8 collection and filter by date and location + ls8_collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2') \ + .filterDate(start_date, end_date) \ + .filterBounds(goa) \ + .filterMetadata('CLOUD_COVER', 'less_than', 10) \ + .map(maskL8sr) \ + .filter(ee.Filter.Or( # Add outlier filter + ee.Filter.date(start_date, outlier_date), + ee.Filter.date(outlier_date.advance(1, 'day'), end_date) + )) \ + .map(lambda image: image.clip(goa)) \ + .map(addIndices) + + # Calculate SWIR min/max for SMI calculation + swir_stats = ls8_collection.mean().select('SR_B7').reduceRegion( + reducer=ee.Reducer.minMax(), + geometry=goa, + scale=30 + ) + + swir_min = ee.Number(swir_stats.get('SR_B7_min')) + swir_max = ee.Number(swir_stats.get('SR_B7_max')) + + # Function to calculate SMI using SWIR bands + def addSMI(image): + smi = image.select('SR_B7').subtract(swir_min) \ + .divide(swir_max.subtract(swir_min)) \ + .multiply(-1).add(1).rename('smi') + return image.addBands(smi) + + # Add SMI to collection + ls8_with_smi = ls8_collection.map(addSMI) + + # Select bands for trend analysis + trend_bands = ['ndvi', 'evi', 'mirbi', 'ndfi', 'bsi', 'ndmi', 'nbr', 'nbr2', 'msavi', 'smi', 'ST_B10'] + ls8_with_smi = ls8_with_smi.select(trend_bands).sort('system:time_start') + + # Add a time band (in years) + def addTimeBand(image): + years = ee.Date(image.get('system:time_start')).difference(ee.Date(start_date), 'year') + return image.addBands(ee.Image.constant(years).float().rename('time')) + + collection_with_time = ls8_with_smi.map(addTimeBand) + + # Calculate trends for each band and combine into a single image + all_trends = None + + for band in trend_bands: + print(f"Calculating trend for {band}...") + + # Select the index and time bands + stacked = collection_with_time.select(['time', band]) + + # Perform linear regression + regression = stacked.reduce(ee.Reducer.linearFit()) + + # Extract slope and intercept + slope = regression.select('scale').rename(f'{band}_Slope') + intercept = regression.select('offset').rename(f'{band}_Intercept') + + # Combine with previous trends + if all_trends is None: + all_trends = slope.addBands(intercept) + else: + all_trends = all_trends.addBands(slope).addBands(intercept) + + # Export the combined trends + export_to_asset( + all_trends, + 'users/jonasnothnagel/Trend2023_landsat_py', + goa, + 'Landsat_Trends_2023_py', + scale=30 + ) + + return all_trends, ls8_with_smi + +# Function to process CHIRPS precipitation data +def process_chirps_trends(goa, start_date='1982-01-01', end_date='2022-12-31'): + """ + Process CHIRPS precipitation data and calculate rainfall trends. + """ + print("Processing CHIRPS precipitation data and calculating trends...") + + # Load CHIRPS data + chirps = ee.ImageCollection('UCSB-CHG/CHIRPS/DAILY') \ + .filterDate(start_date, end_date) \ + .filterBounds(goa) + + # Function to compute the yearly sum + def createYearlySum(year): + # Filter for the specific year + year_filter = chirps.filter(ee.Filter.calendarRange(year, year, 'year')) + + # Create the yearly sum + yearly_sum = year_filter.sum().clip(goa) + + # Add the year as a property + return yearly_sum.set('year', year) \ + .set('system:time_start', ee.Date.fromYMD(year, 1, 1).millis()) \ + .rename('precipitation') + + # Create a list of yearly sums + years = ee.List.sequence(1982, 2021) # Match JS implementation + yearly_sums = years.map(createYearlySum) + + # Convert to ImageCollection + yearly_sums_collection = ee.ImageCollection.fromImages(yearly_sums) + + # Add time band + def addTimeBand(image): + time = ee.Date(image.get('system:time_start')).difference(ee.Date('1982-01-01'), 'year') + return image.addBands(ee.Image.constant(time).rename('time').float()) + + collection_with_time = yearly_sums_collection.map(addTimeBand) + + # Calculate trend + stacked = collection_with_time.select(['time', 'precipitation']) + regression = stacked.reduce(ee.Reducer.linearFit()) + slope = regression.select('scale').rename('rain_Slope') + intercept = regression.select('offset').rename('rain_Intercept') + trend = slope.addBands(intercept) + + # Export the trend + export_to_asset( + trend, + 'users/jonasnothnagel/Trend2022_rain_new_py', + goa, + 'Precipitation_Trend_1982_2022_py', + scale=30 + ) + + return trend, yearly_sums_collection + +# Function to process SMAP soil moisture data +def process_smap_trends(goa, start_date='2015-04-01', end_date='2023-02-28'): + """ + Process SMAP soil moisture data and calculate trends. + Note: SMAP data starts from April 2015. + """ + print("Processing SMAP soil moisture data and calculating trends...") + + # Load SMAP data + smap = ee.ImageCollection('NASA/SMAP/SPL3SMP_E/005') \ + .filterDate(start_date, end_date) \ + .filterBounds(goa) \ + .select(['soil_moisture_am']) \ + .map(lambda image: image.clip(goa)) + + # Add time band + def addTimeBand(image): + time = ee.Date(image.get('system:time_start')).difference(ee.Date('2015-04-01'), 'year') + return image.addBands(ee.Image.constant(time).rename('time').float()) + + # Apply time band to each image in the collection + soil_moisture_with_time = smap.map(addTimeBand) + + # Calculate trend + regression = soil_moisture_with_time.reduce(ee.Reducer.linearFit()) + slope = regression.select('scale').rename('sm_surface_Slope') + intercept = regression.select('offset').rename('sm_surface_Intercept') + trend = slope.addBands(intercept) + + # Export the trend + export_to_asset( + trend, + 'users/jonasnothnagel/Trend2023_SM_new_py', + goa, + 'SM_Trend2015_2023_py', + scale=30 + ) + + return trend, smap + +# Function to process ERA5 relative humidity data +def process_era5_trends(goa, start_date='1980-01-01', end_date='2023-02-28'): + """ + Process ERA5 data and calculate relative humidity trends. + """ + print("Processing ERA5 relative humidity data and calculating trends...") + + # Load ERA5 data + era5 = ee.ImageCollection("ECMWF/ERA5_LAND/MONTHLY_AGGR") \ + .filterDate(start_date, end_date) \ + .filterBounds(goa) \ + .map(lambda image: image.clip(goa)) + + # Function to calculate vapor pressure + def calcVaporPressure(temp): + denom = temp.add(243.5) + num = temp.multiply(19.67) # Note: JS uses 19.67 instead of 17.67 + exponent = num.divide(denom).exp() + return exponent.multiply(6.112) + + # Calculate RH for each time step + def calculateRH(image): + dewPoint = image.select('dewpoint_temperature_2m') + temperature = image.select('temperature_2m') + + # Calculate vapor pressures + eT = calcVaporPressure(temperature) + eTd = calcVaporPressure(dewPoint) + + # Compute relative humidity (%) + RH = eTd.divide(eT).multiply(100).rename('RH') + + # Add time property + return RH.set('system:time_start', image.get('system:time_start')) + + # Apply RH calculation to the collection + rh_collection = era5.map(calculateRH) + + # Add time band + def addTimeBand(image): + time = ee.Date(image.get('system:time_start')).difference(ee.Date('1980-01-01'), 'year') + return image.addBands(ee.Image.constant(time).rename('time').float()) + + rh_with_time = rh_collection.map(addTimeBand) + + # Calculate trend + regression = rh_with_time.reduce(ee.Reducer.linearFit()) + slope = regression.select('scale').rename('rh_Slope') + intercept = regression.select('offset').rename('rh_Intercept') + trend = slope.addBands(intercept) + + # Export the trend + export_to_asset( + trend, + 'users/jonasnothnagel/Trend2024_RH_new_py', + goa, + 'RH_Trend1980_2023_py', + scale=30 + ) + + return trend, rh_collection + +# Function to merge all trend layers +def merge_trend_layers(ls_trends, rain_trend, sm_trend, rh_trend): + """ + Merge all trend layers into a single multi-band image. + """ + # Combine all trend layers + all_trends = ls_trends.addBands(rain_trend).addBands(sm_trend).addBands(rh_trend) + + return all_trends + +# Function to export the trends to Google Earth Engine assets +def export_to_asset(image, asset_name, region, description=None, scale=30, export_bounds=None): + """ + Export an image to a Google Earth Engine asset. + Deletes the asset first if it already exists. + Allows specifying explicit export bounds. + """ + if description is None: + description = asset_name.split('/')[-1] + + # --- Check and delete existing asset --- + try: + asset_info = ee.data.getInfo(asset_name) + if asset_info: + print(f"Asset {asset_name} already exists. Deleting...") + ee.data.deleteAsset(asset_name) + print(f"Asset {asset_name} deleted.") + except ee.EEException as e: + # Handle case where asset doesn't exist (getInfo throws an EEException) + if 'not found' in str(e): + print(f"Asset {asset_name} not found. Proceeding with export.") + else: + print(f"Error checking/deleting asset {asset_name}: {e}. Proceeding with export attempt...") + except Exception as e: + # Catch other potential errors during check/delete + print(f"Unexpected error checking/deleting asset {asset_name}: {e}. Proceeding with export attempt...") + # -------------------------------------- + + # Use provided bounds if available, otherwise use the region geometry's bounds + export_region = export_bounds if export_bounds else region + + print(f"Starting export task to Asset: {description}") + task = ee.batch.Export.image.toAsset( + image=image, # Image should be pre-projected and cast + description=description, + assetId=asset_name, + region=export_region, + scale=scale, + crs='EPSG:3857', + maxPixels=1e13 + ) + + task.start() + print(f"Task started (id: {task.id}). Check GEE Tasks or use monitoring tools.") + return task + +# Function to export the trends to Google Drive +def export_to_drive(image, filename, region, description=None, folder='GEE_Exports', scale=30, export_bounds=None): + """ + Export an image to Google Drive. + Allows specifying explicit export bounds. + """ + if description is None: + description = filename + + # Use provided bounds if available, otherwise use the region geometry's bounds + export_region = export_bounds if export_bounds else region + + task = ee.batch.Export.image.toDrive( + image=image, # Image should be pre-projected and cast + description=description, + folder=folder, + fileNamePrefix=filename, + region=export_region, + scale=scale, + crs='EPSG:3857', + maxPixels=1e13 + ) + + task.start() + print(f"Started export task to Drive: {description}") + return task + +def main(): + """ + Main function to process all trends and export results. + Exports two versions: one matching inputResampled extent, one covering the full study area. + """ + # Initialize Earth Engine + initialize_ee() + + # Get Goa boundary + print("Retrieving Goa boundary...") + goa = get_goa_boundary() + if goa is None: + print("Error: Could not retrieve Goa boundary") + return + + print("Successfully retrieved Goa boundary") + + # Process Landsat trends + print("\nProcessing Landsat trends...") + landsat_trends, landsat_collection = process_landsat_trends(goa) + print("Landsat trends processed successfully") + + # Process CHIRPS precipitation trends + print("\nProcessing CHIRPS precipitation trends...") + rain_trends, rain_collection = process_chirps_trends(goa) + print("CHIRPS precipitation trends processed successfully") + + # Process SMAP soil moisture trends + print("\nProcessing SMAP soil moisture trends...") + sm_trends, sm_collection = process_smap_trends(goa) + print("SMAP soil moisture trends processed successfully") + + # Process ERA5 relative humidity trends + print("\nProcessing ERA5 relative humidity trends...") + rh_trends, rh_collection = process_era5_trends(goa) + print("ERA5 relative humidity trends processed successfully") + + # Merge all trend layers + print("\nMerging all trend layers...") + all_trends = landsat_trends.addBands(rain_trends).addBands(sm_trends).addBands(rh_trends) + + # --- Define Target Export Bounds (from inputResampled.tif in EPSG:3857) --- + target_bounds_coords = [ + [8246820.0, 1680600.0], # bottom-left (x, y) + [8275140.0, 1680600.0], # bottom-right (x, y) + [8275140.0, 1767960.0], # top-right (x, y) + [8246820.0, 1767960.0], # top-left (x, y) + [8246820.0, 1680600.0] # close the loop + ] + target_export_region_limited = ee.Geometry.Polygon(target_bounds_coords, proj='EPSG:3857', evenOdd=False) + + # --- Explicitly set data type and CRS before export --- + print("Casting final trend image to float32 and setting projection to EPSG:3857...") + # Apply casting and projection ONCE to the merged image + # Exports will use this projected image but different bounding regions + all_trends_export_ready = all_trends.toFloat() \ + .reproject(crs='EPSG:3857', scale=30) + + # --- EXPORT 1: Limited Extent (Matching inputResampled.tif) --- + print("\n--- Starting Export for Limited Extent (Match JS Output Grid) ---") + asset_id_limited = 'users/jonasnothnagel/TrendFirePy_LimitedExtent_py' + drive_filename_limited = 'TrendFirePy_LimitedExtent' + + # Export Asset (Limited) + export_to_asset( + all_trends_export_ready, + asset_id_limited, + goa, # Original region for context, bounds override + description=f'{asset_id_limited.split("/")[-1]}_Asset', + scale=30, + export_bounds=target_export_region_limited # Use the limited bounds + ) + + # Export Drive (Limited) + export_to_drive( + all_trends_export_ready, + drive_filename_limited, + goa, # Original region for context, bounds override + description=f'{drive_filename_limited}_Drive', + folder='GEE_Exports', + scale=30, + export_bounds=target_export_region_limited # Use the limited bounds + ) + + # --- EXPORT 2: Full Extent (Covering pa_boundary.shp) --- + print("\n--- Starting Export for Full Study Area Extent ---") + asset_id_full = 'users/jonasnothnagel/TrendFirePy_FullExtent_py' + drive_filename_full = 'TrendFirePy_FullExtent' + + # Export Asset (Full) - Use goa geometry for bounds implicitly + export_to_asset( + all_trends_export_ready, + asset_id_full, + goa, # Let GEE determine bounds from this geometry + description=f'{asset_id_full.split("/")[-1]}_Asset', + scale=30 + # No export_bounds specified, defaults to region (goa) + ) + + # Export Drive (Full) - Use goa geometry for bounds implicitly + export_to_drive( + all_trends_export_ready, + drive_filename_full, + goa, # Let GEE determine bounds from this geometry + description=f'{drive_filename_full}_Drive', + folder='GEE_Exports', + scale=30 + # No export_bounds specified, defaults to region (goa) + ) + + print("\nAnalysis completed successfully!") + print("Multiple export tasks started. Monitor GEE Tasks.") + + # Return the original merged trends (before final reprojection for export) + return { + 'trends': all_trends, + 'collections': { + 'landsat': landsat_collection, + 'rain': rain_collection, + 'sm': sm_collection, + 'rh': rh_collection + } + } + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/compare_trends.py b/compare_trends.py new file mode 100644 index 0000000..d14629a --- /dev/null +++ b/compare_trends.py @@ -0,0 +1,205 @@ +import rasterio +import os +import numpy as np +import geopandas as gpd +import matplotlib.pyplot as plt +from shapely.geometry import box + +# Function to plot the bounding boxes +def plot_extents(gdf_list, labels, colors, boundary_shp_path=None, title="GeoTIFF Extents"): + """Plots bounding boxes from GeoDataFrames, optionally with a boundary shapefile.""" + fig, ax = plt.subplots(1, 1, figsize=(10, 10)) + + boundary_gdf = None + # Plot study area boundary first if provided + if boundary_shp_path and os.path.exists(boundary_shp_path): + try: + boundary_gdf = gpd.read_file(boundary_shp_path) + # Ensure boundary CRS matches the first GeoTIFF's CRS if possible + if gdf_list and gdf_list[0].crs: + try: + boundary_gdf = boundary_gdf.to_crs(gdf_list[0].crs) + except Exception as crs_err: + print(f"Warning: Could not reproject boundary shapefile to {gdf_list[0].crs}: {crs_err}") + boundary_gdf.plot(ax=ax, facecolor='none', edgecolor='black', linestyle='--', label='Study Area Boundary (pa_boundary.shp)') + except Exception as e: + print(f"Error reading or plotting boundary shapefile {boundary_shp_path}: {e}") + + # Plot the bounding boxes + for gdf, label, color in zip(gdf_list, labels, colors): + if gdf is not None and not gdf.empty: + gdf.plot(ax=ax, facecolor='none', edgecolor=color, label=label) + + ax.set_title(title) + ax.set_xlabel("Longitude / Easting") + ax.set_ylabel("Latitude / Northing") + ax.legend() + plt.tight_layout() + plt.show() + +# Modified comparison function +def compare_tifs(file1_path, file2_path, plot=True, boundary_path=None): + """ + Compares metadata and basic statistics of two GeoTIFF files, optionally plots extents. + """ + print(f"Comparing:\n (1) {os.path.basename(file1_path)}\n (2) {os.path.basename(file2_path)}\n") + + if not os.path.exists(file1_path): + print(f"Error: File not found - {file1_path}") + return + if not os.path.exists(file2_path): + print(f"Error: File not found - {file2_path}") + return + + gdf_list = [] + labels = [os.path.basename(file1_path), os.path.basename(file2_path)] + colors = ['red', 'blue'] + + try: + with rasterio.open(file1_path) as ds1, rasterio.open(file2_path) as ds2: + + # --- Metadata Comparison --- + print("--- Metadata Comparison ---") + + meta1 = ds1.meta + meta2 = ds2.meta + + print(f"Number of Bands: (1) {ds1.count:<5} (2) {ds2.count}") + print(f"Data Types: (1) {ds1.dtypes[0]:<10} (2) {ds2.dtypes[0]}") # Show first band's dtype + print(f"CRS: (1) {ds1.crs.to_string() if ds1.crs else 'N/A':<10} (2) {ds2.crs.to_string() if ds2.crs else 'N/A'}") + print(f"Resolution (X): (1) {ds1.res[0]:<10.8f} (2) {ds2.res[0]:.8f}") + print(f"Resolution (Y): (1) {ds1.res[1]:<10.8f} (2) {ds2.res[1]:.8f}") + print(f"Width (pixels): (1) {ds1.width:<5} (2) {ds2.width}") + print(f"Height (pixels): (1) {ds1.height:<5} (2) {ds2.height}") + print(f"Bounds: (1) {ds1.bounds}\n (2) {ds2.bounds}") + # Safely format nodata and compression + nodata1_str = str(ds1.nodata) if ds1.nodata is not None else 'None' + nodata2_str = str(ds2.nodata) if ds2.nodata is not None else 'None' + comp1_str = ds1.compression.value if ds1.compression else 'None' + comp2_str = ds2.compression.value if ds2.compression else 'None' + print(f"NoData Value: (1) {nodata1_str:<10} (2) {nodata2_str}") + print(f"Compression: (1) {comp1_str:<10} (2) {comp2_str}") + + if ds1.count != ds2.count: + print("\n*** Band count differs! ***") + # List expected bands from TrendFire.py calculation + ls_indices = ['ndvi', 'evi', 'mirbi', 'ndfi', 'bsi', 'ndmi', 'nbr', 'nbr2', 'msavi', 'smi', 'ST_B10'] + other_indices = ['rain', 'sm_surface', 'rh'] + expected_bands = [] + for index in ls_indices + other_indices: + expected_bands.extend([f"{index}_Slope", f"{index}_Intercept"]) + + print(f"Expected bands based on TrendFire.py ({len(expected_bands)} bands total):") + # Print first few and last few expected bands for brevity + print(f" {', '.join(expected_bands[:5])} ... {', '.join(expected_bands[-5:])}") + + # Try reading band descriptions if they exist + print("\nAttempting to read band descriptions...") + try: + print("\nBand descriptions (1) - inputResampled.tif:") + if ds1.descriptions: + for i, desc in enumerate(ds1.descriptions): + print(f" Band {i+1}: {desc}") + else: + print(" No descriptions found.") + + print("\nBand descriptions (2) - TrendFirePy_output.tif:") + if ds2.descriptions: + for i, desc in enumerate(ds2.descriptions): + print(f" Band {i+1}: {desc}") + else: + print(" No descriptions found.") + except Exception as e: + print(f"Could not read band descriptions: {e}") + + # --- Data Comparison (Basic Stats for First Band) --- + print("\n--- Basic Statistics (First Band) ---") + try: + data1 = ds1.read(1, masked=True) + data2 = ds2.read(1, masked=True) + + # Check if arrays are comparable in shape + if data1.shape == data2.shape: + print(f"Min Value: (1) {np.ma.min(data1):<10.4f} (2) {np.ma.min(data2):.4f}") + print(f"Max Value: (1) {np.ma.max(data1):<10.4f} (2) {np.ma.max(data2):.4f}") + print(f"Mean Value: (1) {np.ma.mean(data1):<10.4f} (2) {np.ma.mean(data2):.4f}") + print(f"Std Dev: (1) {np.ma.std(data1):<10.4f} (2) {np.ma.std(data2):.4f}") + + # Calculate difference + diff = data1 - data2 + print(f"\nDifference (Band 1) Stats:") + print(f" Min Diff: {np.ma.min(diff):.4f}") + print(f" Max Diff: {np.ma.max(diff):.4f}") + print(f" Mean Diff: {np.ma.mean(diff):.4f}") + print(f" Std Diff: {np.ma.std(diff):.4f}") + else: + print("Arrays have different shapes, cannot compare data directly.") + + except Exception as e: + print(f"Error reading or comparing band data: {e}") + + # --- Prepare data for plotting --- + if plot: + try: + # Get bounds and CRS + b1 = ds1.bounds + crs1 = ds1.crs + b2 = ds2.bounds + crs2 = ds2.crs + + # Create GeoDataFrames for the bounding boxes + if crs1: + geom1 = box(b1.left, b1.bottom, b1.right, b1.top) + gdf1 = gpd.GeoDataFrame([1], geometry=[geom1], crs=crs1) + gdf_list.append(gdf1) + else: + print("Warning: CRS not found for file 1, cannot plot its extent.") + gdf_list.append(None) + + if crs2: + geom2 = box(b2.left, b2.bottom, b2.right, b2.top) + gdf2 = gpd.GeoDataFrame([1], geometry=[geom2], crs=crs2) + # Try to reproject gdf2 to match gdf1 if they differ + if crs1 and crs2 != crs1: + try: + print(f"Reprojecting {labels[1]} extent for plotting...") + gdf2 = gdf2.to_crs(crs1) + except Exception as crs_err: + print(f"Warning: Could not reproject {labels[1]} to {crs1} for plotting: {crs_err}") + gdf_list.append(gdf2) + else: + print("Warning: CRS not found for file 2, cannot plot its extent.") + gdf_list.append(None) + + except Exception as e: + print(f"Error preparing data for plotting: {e}") + # Ensure plot call doesn't fail if prep fails + gdf_list = [None, None] + + except rasterio.RasterioIOError as e: + print(f"Error opening GeoTIFF file: {e}") + gdf_list = [None, None] # Prevent plotting attempt on error + except Exception as e: + print(f"An unexpected error occurred: {e}") + gdf_list = [None, None] # Prevent plotting attempt on error + + # --- Plotting --- + if plot and (gdf_list[0] is not None or gdf_list[1] is not None or (boundary_path and os.path.exists(boundary_path))): + plot_extents(gdf_list, labels, colors, boundary_shp_path=boundary_path) + elif plot: + print("\nPlotting skipped: No valid extents or boundary file found.") + + +if __name__ == "__main__": + # Define file paths relative to the script location or use absolute paths + data_dir = "data" + boundary_shapefile = os.path.join(data_dir, "pa_boundary.shp") # Path to boundary + file1 = os.path.join(data_dir, "inputResampled.tif") # Ground truth (JS output) + file2 = os.path.join(data_dir, "TrendFirePy_output.tif") # Python output + + # Make sure the boundary file exists if we want to plot it + if not os.path.exists(boundary_shapefile): + print(f"Boundary shapefile not found at {boundary_shapefile}. Plot will not include boundary.") + boundary_shapefile = None + + compare_tifs(file1, file2, plot=True, boundary_path=boundary_shapefile) \ No newline at end of file diff --git a/fire_training_data.csv b/fire_training_data.csv new file mode 100644 index 0000000..50ba51a --- /dev/null +++ b/fire_training_data.csv @@ -0,0 +1,120 @@ +geometry,Shape_Leng,Shape_Area,Name,RiskNumeric,bright_ti5,bright_ti4,acq_time,frp,Delta T,acq_date,confidence,scan,instrument,type,version,RiskNumeri,daynight,satellite,track,RiskCatego,latitude,longitude,system_ind,RiskCategory,band_0,band_1,band_2,band_3,band_4,band_5,band_6,band_7,band_8,band_9,band_10,band_11,band_12,band_13,band_14,band_15,band_16,band_17,band_18,band_19,band_20,band_21,band_22,band_23,band_24,band_25,band_26,band_27,band_28,band_29,band_30,band_31,band_32,band_33,band_34,band_35,band_36,band_37,band_38,band_39 +POINT (8261046.147503854 1687053.480279874),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.1590551733970642,307.9532775878906,-0.00139885104727,0.3201126456260681,-0.001422568573616445,0.2932116985321045,-0.00016246738960035145,2.985119104385376,0.003261376405134797,0.030697975307703018,3.0465664863586426,2.6813604831695557,-0.0036697599571198225,0.014680464752018452,-0.005007404368370771,0.2700957953929901,-0.001958254026249051,0.266215056180954,7.6590070724487305,-0.003128026146441698,0.6136714816093445,102.89124298095703,189.32144165039062,90.41915893554688,295.8944091796875,99.33528137207031,2.158346652984619,116.88705444335938,2020.793701171875,-0.010756300762295723,0.6754152178764343,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,325.7350158691406 +POINT (8269121.27344099 1703992.4819680364),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,17.40591049194336,2074.81591796875,0.0439036525785923,17.53630256652832,0.25495290756225586,309.116455078125,-0.0015410155756399035,0.3733777701854706,-0.0025193174369633198,0.3429637551307678,-0.0076751746237277985,3.000619649887085,-0.00023479355149902403,-0.03199981898069382,3.006338357925415,2.7003719806671143,-3.9574781112605706e-05,0.07839220017194748,0.00036779619404114783,0.3396512567996979,-0.0007775118574500084,0.28751593828201294,1.7596813440322876,0.0029018819332122803,0.6433212161064148,89.44823455810547,153.8129119873047,75.77940368652344,307.91851806640625,97.70325469970703,-32.07685852050781,89.23446655273438,2545.909912109375,-0.00813055969774723,0.7351407408714294,-0.10466708987951279,32.834415435791016,0.03671526536345482,20.826221466064453,57.63419723510742 +POINT (8273698.95411243 1723359.7968233791),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.36348646879196167,302.61474609375,-0.005507180467247963,0.41126346588134766,-0.006973599083721638,0.38455930352211,0.013105081394314766,2.6685433387756348,0.01754899136722088,-0.24737334251403809,2.976552724838257,2.7044215202331543,-0.018594350665807724,0.3068135678768158,-0.02038157358765602,0.5888617038726807,-0.008279030211269855,0.36349794268608093,17.001943588256836,-0.011784297414124012,0.8463740348815918,93.1970443725586,101.45000457763672,91.06293487548828,197.44107055664062,107.7288818359375,-100.27291107177734,154.4427947998047,1719.7645263671875,0.0016844321507960558,0.6863299012184143,-0.009360027499496937,30.074121475219727,0.03362371772527695,21.575223922729492,1130.676025390625 +POINT (8262691.528512363 1742415.8060917272),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.10894203186035,2127.662353515625,0.04621821641921997,17.30975914001465,0.11351852864027023,302.8065490722656,0.0006967184599488974,0.4626201391220093,0.0006570483092218637,0.4323788583278656,-0.0004863528592977673,2.695178508758545,-0.0010777385905385017,-0.3229467272758484,2.976552724838257,2.7044215202331543,0.0008184047183021903,0.38251176476478577,0.0008236492285504937,0.6817947626113892,0.0003430768265388906,0.40660104155540466,12.85888385772705,0.00029750625253655016,0.8828385472297668,110.20442962646484,78.87997436523438,92.81378173828125,268.60748291015625,106.46637725830078,-9.98116397857666,91.5356674194336,2283.200439453125,-0.014355246908962727,0.806202232837677,-0.025806233286857605,29.133590698242188,0.038651783019304276,21.50113868713379,2455.502685546875 +POINT (8266441.378044788 1724849.7694401327),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.239013671875,2170.728271484375,0.06290382146835327,15.734601974487305,0.13511884212493896,302.65911865234375,0.001456924481317401,0.4192206859588623,0.001391385798342526,0.38751471042633057,0.0013436608714982867,2.6791539192199707,-0.0006602358189411461,-0.2699742913246155,4.112709045410156,2.169313669204712,0.00031601195223629475,0.33200228214263916,0.00020204129396006465,0.6291626691818237,0.0001446689711883664,0.37762650847435,8.921035766601562,-0.0004270916397217661,0.866394579410553,142.77381896972656,-150.4756622314453,124.31851959228516,47.23599624633789,130.8343048095703,-216.5876922607422,170.01075744628906,2016.5654296875,-0.017416546121239662,0.8421813249588013,-0.07179174572229385,30.308000564575195,0.043228331953287125,21.4822940826416,1875.3851318359375 +POINT (8260008.560439177 1694016.3797484306),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.05279861018061638,301.39337158203125,0.000980521086603403,0.35718193650245667,0.0008993181982077658,0.3255615532398224,-0.0010477304458618164,2.5755677223205566,-0.0019646803848445415,-0.24298910796642303,2.8360955715179443,2.6934564113616943,0.0018763340776786208,0.3040730357170105,0.0016364267794415355,0.5881518721580505,0.00027532136300578713,0.3483513295650482,29.599546432495117,0.0005013903719373047,0.8718056082725525,272.188232421875,-423.9848327636719,228.10162353515625,-169.21009826660156,245.5721435546875,-484.5557861328125,217.9891357421875,1754.978759765625,-0.028565693646669388,0.841781497001648,-0.07124094665050507,28.63713836669922,0.04556915536522865,21.336942672729492,2003.7845458984375 +POINT (8269273.869387842 1724011.8484569872),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.05650223046541214,303.9241943359375,-0.0003618040063884109,0.5089510083198547,-0.0005711097037419677,0.4834989905357361,-0.0012240340001881123,2.8107993602752686,-0.0005812531453557312,-0.30068933963775635,5.156741619110107,1.4496335983276367,0.00041711379890330136,0.3652467429637909,0.0007519519422203302,0.6579996347427368,0.0006055821431800723,0.3874170780181885,18.83531379699707,0.0007618158706463873,0.8434931039810181,161.01174926757812,83.86126708984375,127.25291442871094,257.4933166503906,136.08660888671875,-61.496498107910156,119.26997375488281,2622.40625,-0.019422242417931557,0.8192311525344849,-0.07518620789051056,28.91219139099121,0.032185424119234085,20.424049377441406,1115.2406005859375 +POINT (8261842.827458728 1740785.8249675743),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.12369728088379,2153.84423828125,0.05328503996133804,16.63265609741211,0.06364867836236954,305.688720703125,0.00043539414764381945,0.42504507303237915,0.0003049384104087949,0.3892301917076111,0.0002241056354250759,2.7883102893829346,-0.0005618921131826937,-0.21358342468738556,2.976552724838257,2.7044215202331543,0.000531863362994045,0.2710403501987457,0.0008812326123006642,0.5739607214927673,0.0006144085782580078,0.36449486017227173,4.0576043128967285,0.0005311936256475747,0.8252570629119873,105.54356384277344,144.5693817138672,89.59097290039062,318.4111633300781,106.0201416015625,-9.742173194885254,131.361083984375,2212.525634765625,-0.007421791087836027,0.7529162168502808,-0.06673412770032883,30.914758682250977,0.018310822546482086,21.265974044799805,973.689453125 +POINT (8260828.519457103 1743217.0513302842),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.10894203186035,2127.662353515625,0.04621821641921997,17.30975914001465,0.05544076859951019,302.6738586425781,0.0011251016985625029,0.5081122517585754,0.0010993309551849961,0.4827297031879425,-2.7022244466934353e-05,2.8482565879821777,-0.001069217803888023,-0.28136366605758667,2.976552724838257,2.7044215202331543,0.0006674053729511797,0.34239450097084045,0.0007186589064076543,0.6403369903564453,0.00039420087705366313,0.384140282869339,17.81820297241211,0.0003305537684354931,0.8316002488136292,115.50199890136719,40.818077087402344,98.51343536376953,233.963623046875,114.4507064819336,-78.8373031616211,131.62930297851562,2538.92333984375,-0.010140080004930496,0.8045213222503662,-0.019992897287011147,28.88996124267578,0.03319421783089638,21.81450080871582,2010.753662109375 +POINT (8262478.339771507 1710038.0405431816),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,18.551830291748047,2328.795654296875,0.07300230115652084,14.763771057128906,-0.028422057628631592,306.92620849609375,-0.0017024836270138621,0.38105708360671997,-0.0021273624151945114,0.35291945934295654,-0.00694648502394557,2.899095296859741,-0.00044948700815439224,-0.10497267544269562,3.2029500007629395,2.5971996784210205,0.000495576299726963,0.15261459350585938,0.0014943997375667095,0.43918314576148987,0.00023095546930562705,0.33186253905296326,2.205794334411621,0.0036686700768768787,0.7352124452590942,44.67636489868164,279.069580078125,32.18345260620117,424.4450988769531,33.90730667114258,187.99945068359375,67.21434783935547,2314.35595703125,-0.0035996080841869116,0.7408851981163025,-0.10240248590707779,30.412363052368164,0.05450413003563881,21.40806007385254,1239.5594482421875 +POINT (8266823.213469147 1724946.310596159),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.239013671875,2170.728271484375,0.06290382146835327,15.734601974487305,0.13500067591667175,303.7631530761719,0.002513664774596691,0.5339381098747253,0.0026101565454155207,0.5040708184242249,0.003585441503673792,2.890578269958496,-0.0015083083417266607,-0.29767367243766785,4.112709045410156,2.169313669204712,0.0013047934044152498,0.35252463817596436,0.0017099103424698114,0.6612467169761658,0.0013489931588992476,0.403309166431427,29.91827964782715,0.00027488230261951685,0.837577760219574,78.59945678710938,51.963134765625,74.20702362060547,222.87802124023438,82.23078155517578,-44.7013053894043,148.68031311035156,2597.6865234375,-0.006413158494979143,0.8252103328704834,-0.0655343160033226,29.846113204956055,0.04641435667872429,21.438268661499023,1635.8236083984375 +POINT (8259913.629659097 1757113.239864143),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.1991206407546997,303.88427734375,-0.0012138825841248035,0.4477764368057251,-0.0015484956093132496,0.41557982563972473,0.0009933126857504249,2.7990641593933105,0.0022069753613322973,-0.23482829332351685,2.8782966136932373,2.7207159996032715,-0.0023503743577748537,0.29037052392959595,-0.002228874247521162,0.5964016914367676,-0.0006481950986199081,0.37484970688819885,11.523356437683105,-0.000892146781552583,0.8339175581932068,95.38875579833984,-16.428924560546875,79.26444244384766,185.06964111328125,99.86288452148438,-117.65705871582031,85.8190689086914,2327.594970703125,-0.0114337969571352,0.8114026188850403,-0.0660015419125557,30.757200241088867,0.0418088473379612,20.841373443603516,366.37030029296875 +POINT (8263364.580743245 1721187.0315459208),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.0680285394191742,302.76068115234375,-0.0015416209353134036,0.43631547689437866,-0.001924472744576633,0.40635064244270325,-0.0023346252273768187,2.77661395072937,0.0012908378848806024,-0.24325519800186157,3.1579742431640625,2.646435260772705,-0.001442023436538875,0.29884424805641174,-0.0014218997675925493,0.607657790184021,-0.0008242352632805705,0.3850521147251129,10.353761672973633,5.485091605805792e-05,0.8433982133865356,94.29320526123047,78.33560180664062,82.20511627197266,253.48049926757812,92.97217559814453,-16.412370681762695,106.14305877685547,2240.1396484375,-0.011950474232435226,0.8083029985427856,-0.06615551561117172,29.657501220703125,0.04969991371035576,21.45850372314453,2413.6494140625 +POINT (8267490.1725776 1753115.1961913833),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,21.53333282470703,2424.092041015625,0.07109512388706207,14.932489395141602,0.030272740870714188,302.5074768066406,0.0002969462366309017,0.42880919575691223,9.34655690798536e-05,0.39965328574180603,0.00010308095079381019,2.6573646068573,-0.0003053356194868684,-0.2981160879135132,5.493683815002441,1.311958909034729,-0.00010682357242330909,0.3565613329410553,0.00029675979749299586,0.6530452370643616,0.0005587598425336182,0.38715648651123047,23.50609588623047,0.0003656749613583088,0.8782176971435547,91.0837173461914,-5.189761638641357,78.75733184814453,179.66094970703125,93.6447982788086,-107.00601959228516,67.77201843261719,2179.99609375,-0.009828880429267883,0.8165248036384583,-0.07156074792146683,29.077322006225586,0.03938012197613716,21.203235626220703,797.048095703125 +POINT (8269338.493118312 1732850.0369976254),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.25299620628356934,302.77972412109375,-0.004684533458203077,0.4208238124847412,-0.004691168200224638,0.3903476893901825,0.030100535601377487,2.618131160736084,0.02557196095585823,-0.3008679747581482,2.8360955715179443,2.6934564113616943,-0.027217121794819832,0.36584290862083435,-0.030280569568276405,0.6558443307876587,-0.009945501573383808,0.37961339950561523,16.15848159790039,-0.022507870569825172,0.886866569519043,141.042236328125,250.61968994140625,115.0765380859375,290.7892150878906,122.67909240722656,-37.4490966796875,193.03305053710938,2195.665771484375,-0.011108418926596642,0.7331947088241577,-0.05248381569981575,29.330591201782227,0.029538217931985855,21.792821884155273,1905.299072265625 +POINT (8261015.471451335 1689233.5579069236),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,19.745206832885742,2261.209228515625,0.06798024475574493,15.237241744995117,0.013782313093543053,306.9048767089844,-0.002365390071645379,0.426592618227005,-0.0026836826000362635,0.40020808577537537,-0.004214835353195667,2.915229320526123,0.0005832083988934755,-0.1475318819284439,3.0465664863586426,2.6813604831695557,-0.00016262714052572846,0.19837453961372375,3.4910484828287736e-05,0.50401371717453,-0.00028003143961541355,0.3516034781932831,5.356235504150391,0.0010350196389481425,0.7759370803833008,100.90730285644531,109.3638916015625,68.9222640991211,299.1322326660156,66.55096435546875,29.092041015625,142.37632751464844,2187.4111328125,-0.006572297774255276,0.7543508410453796,-0.19462889432907104,34.09711837768555,0.029871318489313126,21.55828857421875,330.2019958496094 +POINT (8262551.186553756 1692373.4699298441),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.03812141343951225,301.0779724121094,0.0006276571657508612,0.49062424898147583,0.0006685582920908928,0.46894124150276184,-0.0023763992357999086,2.6540894508361816,-0.002280712826177478,-0.3810857832431793,2.8360955715179443,2.6934564113616943,0.0018481886945664883,0.4392758905887604,0.0015421814750880003,0.7249793410301208,0.0007696698303334415,0.4205387234687805,16.42145538330078,0.0008436868083663285,0.8989323973655701,158.59384155273438,-79.0983657836914,120.75804901123047,133.7740936279297,133.72683715820312,-167.96917724609375,106.06958770751953,2415.214111328125,-0.019111355766654015,0.8450489044189453,-0.06890227645635605,28.8196964263916,0.028872251510620117,21.2236385345459,2004.28955078125 +POINT (8264997.210812866 1702311.9300384796),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,19.36339569091797,2376.865478515625,0.07109512388706207,14.932489395141602,0.12710490822792053,302.681396484375,0.0005270737456157804,0.4871583580970764,0.00043277282384224236,0.45737335085868835,0.0017844249960035086,2.8644189834594727,0.0007470379932783544,-0.24840016663074493,5.493683815002441,1.311958909034729,-0.0009785880101844668,0.2991999685764313,-0.0010224493453279138,0.6111723184585571,-0.0003901943564414978,0.38456615805625916,16.32535171508789,-0.0007115062326192856,0.8289574980735779,131.88140869140625,119.92657470703125,102.00554656982422,313.31195068359375,109.4997787475586,6.06059455871582,135.569091796875,2459.155517578125,-0.01302994042634964,0.8107378482818604,-0.04451149329543114,28.981529235839844,0.02864653244614601,21.671274185180664,2501.505615234375 +POINT (8265286.706246727 1720361.0192005965),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.03777959570288658,304.1520080566406,0.0006314676138572395,0.4967663884162903,0.00083946279482916,0.4570050537586212,-3.996360464952886e-05,3.0166451930999756,-0.0018933932296931744,-0.188356414437294,2.306614875793457,2.9972360134124756,0.0020206314511597157,0.23700091242790222,0.00303904851898551,0.5503965020179749,0.0018738353392109275,0.3657313585281372,15.850967407226562,0.002310830866917968,0.7681255340576172,84.9875717163086,48.49900436401367,76.79834747314453,229.00830078125,88.90613555908203,-65.05560302734375,120.24674224853516,2717.59375,-0.005849795415997505,0.8120705485343933,-0.0301418025046587,29.389135360717773,0.04379437491297722,21.15009307861328,601.2744140625 +POINT (8266977.945204822 1722960.441873232),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,19.787586212158203,2232.0830078125,0.06290382146835327,15.734601974487305,0.1435348391532898,300.39239501953125,0.0002742635551840067,0.40009546279907227,0.00012423351290635765,0.36784031987190247,-0.00013893292634747922,2.5854263305664062,-0.0008253360283561051,-0.3080812394618988,4.112709045410156,2.169313669204712,0.0009690260631032288,0.3653510510921478,0.0005459303501993418,0.6604946851730347,8.955969678936526e-05,0.3893379271030426,31.799184799194336,-0.0003957342414651066,0.8977577686309814,92.25000762939453,-34.058204650878906,79.56815338134766,154.13966369628906,90.94336700439453,-99.10833740234375,77.68856048583984,1985.6202392578125,-0.013151409104466438,0.831497311592102,-0.04462631791830063,28.335840225219727,0.05393192917108536,21.271175384521484,3452.29345703125 +POINT (8264448.853411394 1731887.657519712),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,16.300752639770508,2173.091796875,0.05328503996133804,16.63265609741211,0.14595967531204224,304.1439208984375,-0.0012339920504018664,0.39607536792755127,-0.0014454085612669587,0.36774393916130066,0.0021863430738449097,2.7861526012420654,0.002834518440067768,-0.17639540135860443,3.298588752746582,2.5584447383880615,-0.0031664699781686068,0.23210573196411133,-0.00246681016869843,0.5310089588165283,-0.0005214113625697792,0.35666337609291077,6.814953327178955,-0.0009108748636208475,0.8111509084701538,129.267822265625,-59.83455276489258,113.5224609375,115.63308715820312,130.11634826660156,-176.88720703125,161.3873748779297,1894.763427734375,-0.01168338768184185,0.7807043194770813,-0.10586537420749664,31.62586212158203,0.0454891175031662,21.512033462524414,808.9228515625 +POINT (8249699.111563255 1762539.660921),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,19.382850646972656,2113.504638671875,0.04423021897673607,17.48790740966797,0.051474228501319885,302.9670715332031,-0.00160194409545511,0.4932066798210144,-0.0017336014425382018,0.46702298521995544,-0.0026895334012806416,2.913046360015869,0.0006098828162066638,-0.23620019853115082,2.3598642349243164,2.984099864959717,-0.0005892888875678182,0.2963998019695282,-0.00045201831380836666,0.5998298525810242,-0.0002218000590801239,0.3759107291698456,25.976356506347656,0.0006646952824667096,0.8039725422859192,154.8152618408203,68.13226318359375,129.23353576660156,248.87908935546875,129.8836669921875,-49.919857025146484,189.59017944335938,2406.3642578125,-0.011352026835083961,0.7726869583129883,-0.06790860742330551,29.711496353149414,0.04321415722370148,21.72971534729004,2078.54443359375 +POINT (8261181.633496349 1737151.5131185204),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.12369728088379,2153.84423828125,0.05328503996133804,16.63265609741211,0.07660961151123047,303.3529357910156,0.001785141066648066,0.41765549778938293,0.0017335254233330488,0.388749897480011,0.003004734870046377,2.742203712463379,-0.0005311852437444031,-0.2359922230243683,3.2316770553588867,2.59718656539917,0.0004947457346133888,0.2924010157585144,0.0006432573427446187,0.6031634211540222,0.0003137508756481111,0.38240352272987366,5.393972396850586,-0.0003394868108443916,0.8513416647911072,126.53034210205078,-40.749820709228516,107.3917465209961,156.82940673828125,113.51212310791016,-109.016845703125,147.71905517578125,2045.8905029296875,-0.012822668068110943,0.8014622330665588,-0.09826058894395828,31.831863403320312,0.02201393060386181,21.478727340698242,1122.7733154296875 +POINT (8261552.063117143 1719890.3674817118),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.300752639770508,2173.091796875,0.05328503996133804,16.63265609741211,0.08311744034290314,307.2726135253906,1.598159724380821e-05,0.35455119609832764,-0.0003264515253249556,0.32171350717544556,-0.001953464699909091,2.927485227584839,-0.0010137929348275065,-0.037232089787721634,3.298588752746582,2.5584447383880615,0.0003755649668164551,0.08805225044488907,0.001480843173339963,0.35683029890060425,0.001387083437293768,0.2852901816368103,5.180638313293457,0.0026825314853340387,0.6797186732292175,126.26046752929688,25.516143798828125,113.95465087890625,161.3827667236328,117.74287414550781,-107.84561920166016,155.04196166992188,1944.988037109375,-0.008643073961138725,0.7303717136383057,-0.07374374568462372,30.790075302124023,0.027237525209784508,21.205472946166992,880.5986328125 +POINT (8261353.889461433 1748217.5277047132),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.17526425421237946,305.9162902832031,-0.0008680293103680015,0.4052399694919586,-0.000991616165265441,0.37123364210128784,0.0040992246940732,2.878767728805542,0.0030624577775597572,-0.14735622704029083,2.976552724838257,2.7044215202331543,-0.003201441140845418,0.19851438701152802,-0.0032892562448978424,0.4987478256225586,-0.0008780166390351951,0.3456137180328369,11.499750137329102,-0.0024313784670084715,0.7734515070915222,93.22777557373047,141.59207153320312,87.63451385498047,248.69747924804688,104.98493957519531,-42.82523727416992,113.294677734375,2204.594482421875,-0.004330268129706383,0.7205092310905457,-0.026762770488858223,31.050888061523438,0.022190114483237267,21.29987907409668,691.5078125 +POINT (8262066.107653767 1763827.2445334455),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.19830422103405,301.5170593261719,-0.0070106107741594315,0.6894866824150085,-0.007769692223519087,0.6708515286445618,-0.00040294864447787404,3.00681209564209,0.008339139632880688,-0.40163829922676086,2.306614875793457,2.9972360134124756,-0.0078113144263625145,0.45161622762680054,-0.008176960982382298,0.7456730604171753,-0.005086902994662523,0.4415399134159088,29.39374542236328,-0.004566200077533722,0.8459840416908264,176.56198120117188,-160.8659210205078,154.5343017578125,48.6362419128418,156.1862335205078,-224.57986450195312,187.99110412597656,2886.087890625,-0.023310748860239983,0.8660500049591064,-0.038287628442049026,28.582712173461914,0.05084999278187752,21.16116714477539,1119.0450439453125 +POINT (8252966.42941239 1685295.5393211427),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,23.504873275756836,2569.070068359375,0.09081510454416275,13.04919147491455,-0.018681438639760017,305.7333984375,0.003071489278227091,0.4161742627620697,0.0028597842901945114,0.3936383128166199,0.003299175063148141,2.8843441009521484,-0.002601898740977049,-0.15189096331596375,2.7865242958068848,2.740579843521118,0.002226866316050291,0.20705026388168335,0.0035243737511336803,0.5112313628196716,0.001653237733989954,0.35217246413230896,2.962559700012207,0.0014740470796823502,0.782730221748352,79.71941375732422,97.75496673583984,79.07776641845703,238.92477416992188,89.12870788574219,-51.9503288269043,133.95274353027344,2195.6513671875,-0.006646840833127499,0.7720575928688049,-0.1395138055086136,30.897869110107422,0.012419543229043484,21.54703712463379,199.9700164794922 +POINT (8266493.973501359 1702502.6333610571),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,17.637788772583008,2430.905517578125,0.06117723137140274,15.88566780090332,0.056207891553640366,301.68170166015625,0.0006864207680337131,0.39570796489715576,0.0006284348201006651,0.3671559691429138,-0.0005949529586359859,2.5686933994293213,-0.0008131762151606381,-0.32097843289375305,5.493683815002441,1.311958909034729,0.0004567378491628915,0.38393571972846985,0.000377143471268937,0.6751805543899536,0.00017674225091468543,0.3934765160083771,21.581520080566406,0.0002755316672846675,0.9023265838623047,171.00454711914062,-152.9395294189453,140.9563446044922,35.191158294677734,132.32679748535156,-160.06948852539062,164.83139038085938,1639.147705078125,-0.015814851969480515,0.8103013634681702,-0.04471790790557861,28.525503158569336,0.031126869842410088,21.374767303466797,2110.1572265625 +POINT (8264219.0261052 1692366.3916520006),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.05937211588025093,301.96502685546875,0.0014667330542579293,0.4448661208152771,0.0016351545928046107,0.41852545738220215,-0.00018382012785878032,2.664808511734009,-0.0028333121445029974,-0.3063919246196747,2.8360955715179443,2.6934564113616943,0.0022741924040019512,0.3700748085975647,0.0028053384739905596,0.6585643887519836,0.0021715781185775995,0.3816904127597809,27.656890869140625,0.0013535136822611094,0.8734142184257507,170.21180725097656,-18.4632625579834,147.85638427734375,132.1824188232422,162.1001434326172,-190.08726501464844,142.36245727539062,2138.1376953125,-0.019585730507969856,0.810249388217926,-0.05248381569981575,29.330591201782227,0.029538217931985855,21.792821884155273,1851.169677734375 +POINT (8263441.534239668 1755058.9681129523),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.0963275134563446,302.47332763671875,-0.0026545505970716476,0.40231403708457947,-0.0025840953458100557,0.36753368377685547,-0.0018266853876411915,2.740663766860962,0.0029578227549791336,-0.20001842081546783,2.8782966136932373,2.7207159996032715,-0.002690128516405821,0.25594624876976013,-0.0032235905528068542,0.5495625734329224,-0.0015781554393470287,0.3538074791431427,19.21757698059082,-0.001017609378322959,0.8242944478988647,94.40872192382812,-17.333995819091797,76.29496765136719,170.0533905029297,99.69710540771484,-126.63162994384766,82.61861419677734,1996.3101806640625,-0.010750885121524334,0.7795593738555908,-0.03604848310351372,29.62470817565918,0.03766153007745743,21.4419002532959,1507.030517578125 +POINT (8263953.761028758 1720732.4310992796),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.07837918400764465,302.2860412597656,-0.00012828508624807,0.4345840811729431,-0.0002606911875773221,0.40570545196533203,-0.00028381001902744174,2.6609930992126465,0.0003336509398650378,-0.30299118161201477,3.1579742431640625,2.646435260772705,-0.0005240152822807431,0.36477136611938477,-0.00043382972944527864,0.6589313745498657,-7.871473644627258e-05,0.3883114755153656,17.684913635253906,-2.5615909180487506e-05,0.8786348104476929,113.67413330078125,31.870874404907227,99.77638244628906,212.45851135253906,98.50244140625,-33.61927032470703,115.49274444580078,2219.52587890625,-0.01280528586357832,0.8009641766548157,-0.05736849829554558,29.00293731689453,0.043110255151987076,21.762653350830078,1963.4893798828125 +POINT (8273554.2578175375 1723842.1766357203),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,16.178546905517578,2108.369873046875,0.06290382146835327,15.734601974487305,0.03720001503825188,300.8758544921875,0.001645763055421412,0.3853974938392639,0.0017168783815577626,0.35314232110977173,-0.001241031801328063,2.5749945640563965,-0.0035668006166815758,-0.286088764667511,5.83398962020874,1.2709428071975708,0.003770690644159913,0.3430604636669159,0.003462736727669835,0.6341547966003418,0.0013582200044766068,0.3730332553386688,40.55246353149414,0.0011008295696228743,0.8899705410003662,166.3529510498047,-238.62579345703125,124.54154205322266,-10.568404197692871,131.48287963867188,-234.65650939941406,147.0846405029297,1388.1617431640625,-0.016398150473833084,0.8131328225135803,-0.04270009323954582,28.151073455810547,0.042068544775247574,20.384599685668945,1261.284423828125 +POINT (8268235.0026916 1725959.7999124222),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,18.239013671875,2170.728271484375,0.06290382146835327,15.734601974487305,0.07582572102546692,303.1377258300781,0.0016410751268267632,0.5610355734825134,0.0016956148901954293,0.531405508518219,0.0037005303893238306,2.9535088539123535,-0.00041632409556768835,-0.29349038004875183,4.112709045410156,2.169313669204712,0.0006662926753051579,0.3425050973892212,0.0007240552804432809,0.6542083621025085,0.0004185580473858863,0.4028489887714386,22.534149169921875,-0.00044012913713231683,0.8238675594329834,131.92637634277344,-48.12061309814453,112.44924926757812,169.68392944335938,63.932857513427734,105.38275146484375,187.93646240234375,2600.82275390625,-0.00838171225041151,0.8250625729560852,-0.05506659299135208,29.576372146606445,0.038734763860702515,21.40384292602539,803.92529296875 +POINT (8266388.990074024 1694551.274522168),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,21.10080909729004,2478.678955078125,0.06601659208536148,15.423352241516113,-0.1493058204650879,306.282470703125,0.0070447055622935295,0.37799072265625,0.005783691070973873,0.3583005666732788,-0.009871874935925007,3.0098838806152344,-0.011458190158009529,-0.04249124228954315,5.493683815002441,1.311958909034729,0.01018204353749752,0.11473958194255829,0.012063218280673027,0.38115671277046204,0.004262955859303474,0.2807195484638214,20.695884704589844,0.009791607968509197,0.6552827954292297,112.58413696289062,110.73049926757812,108.11543273925781,227.6793670654297,122.49010467529297,-67.68344116210938,137.37542724609375,2473.015625,-0.00875935424119234,0.7617656588554382,-0.09916195273399353,29.665870666503906,0.03187447041273117,20.558530807495117,1064.2706298828125 +POINT (8261219.219836153 1684957.6648397886),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,22.6862735748291,2552.69091796875,0.07669062167406082,14.396920204162598,0.030689295381307602,303.5072326660156,0.0038372769486159086,0.4495801031589508,0.004071256145834923,0.42837098240852356,0.0024717499036341906,2.752889394760132,-0.0035445140674710274,-0.26724880933761597,2.0055959224700928,3.0989205837249756,0.0030275858007371426,0.3272094130516052,0.003130686469376087,0.6301913261413574,0.001734824967570603,0.38191744685173035,6.609221935272217,0.0006786038284189999,0.8526982069015503,63.1298713684082,94.74947357177734,59.43310546875,263.9061584472656,71.206787109375,-37.44039535522461,105.55801391601562,2340.80322265625,-0.004466347396373749,0.8006084561347961,-0.06534507125616074,29.380664825439453,0.03097464330494404,21.76676368713379,1248.38525390625 +POINT (8250397.364717637 1755368.375313728),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,20.66444969177246,2120.4052734375,0.04423021897673607,17.48790740966797,0.10646850615739822,302.9615783691406,0.005014218855649233,0.4862692356109619,0.0050658248364925385,0.46310389041900635,0.003656828310340643,2.8269917964935303,-0.003927069716155529,-0.27665600180625916,3.006338357925415,2.7003719806671143,0.0034251627512276173,0.33918625116348267,0.003379173344001174,0.6446586847305298,0.0017296969890594482,0.39197438955307007,13.754830360412598,0.0005045743891969323,0.8430717587471008,78.96881103515625,198.7745361328125,54.847686767578125,393.4236145019531,48.36432647705078,140.8699951171875,98.94148254394531,2569.42578125,-0.007934837602078915,0.7957490086555481,-0.06146763637661934,30.92523956298828,0.02991015464067459,21.787553787231445,1128.42919921875 +POINT (8261456.143758265 1739123.713541585),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,17.40591049194336,2074.81591796875,0.0439036525785923,17.53630256652832,0.14065667986869812,308.1080017089844,-0.001716605038382113,0.4141395390033722,-0.002478592097759247,0.38111451268196106,-0.013009009882807732,3.0417320728302,-0.0028097883332520723,-0.07306268066167831,3.006338357925415,2.7003719806671143,0.002877117833122611,0.12042617797851562,0.004383511375635862,0.399059534072876,0.0009993977146223187,0.3100510835647583,3.617776393890381,0.006949680391699076,0.6737844944000244,89.58692169189453,98.87937927246094,80.56713104248047,264.61767578125,98.05528259277344,-64.78831481933594,94.866943359375,2557.598876953125,-0.0073540392331779,0.7604257464408875,-0.10466708987951279,32.834415435791016,0.03671526536345482,20.826221466064453,211.67398071289062 +POINT (8262969.966020776 1736118.2703905904),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.05792616680264473,307.1551208496094,-0.0008305389201268554,0.39923617243766785,-0.0009881769074127078,0.3714723587036133,-0.0008701516198925674,2.8861184120178223,0.0003406304167583585,-0.12789414823055267,3.0465664863586426,2.6813604831695557,-0.00045663610217161477,0.18644283711910248,0.00031854267581366,0.4777415096759796,0.000665009138174355,0.33057400584220886,7.686184883117676,0.001145554124377668,0.7569004893302917,118.54546356201172,88.72157287597656,92.86561584472656,268.12969970703125,93.51020812988281,-9.483024597167969,150.03648376464844,2096.291259765625,-0.008658132515847683,0.7385255694389343,-0.15413472056388855,32.54884338378906,0.040253520011901855,21.723073959350586,564.7798461914062 +POINT (8266019.501779899 1705007.3604806927),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,17.637788772583008,2430.905517578125,0.06117723137140274,15.88566780090332,0.10756994038820267,302.3316650390625,-0.00041710553341545165,0.545075535774231,-0.0004507893754635006,0.5191692113876343,0.0019531315192580223,2.870347499847412,0.0014157391851767898,-0.3151480555534363,5.316018104553223,1.480040192604065,-0.001618637004867196,0.3739423453807831,-0.0012433043448254466,0.673336386680603,-0.0002833984908647835,0.40094754099845886,24.242244720458984,-0.0006605049129575491,0.8407925963401794,154.27691650390625,-94.75945281982422,115.11351776123047,127.18408203125,113.91524505615234,-134.88214111328125,182.7025909423828,2393.664794921875,-0.012259970419108868,0.8340820670127869,-0.03704620152711868,28.62795639038086,0.04611867293715477,21.419403076171875,3166.17919921875 +POINT (8264263.179335943 1717601.9789250183),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.054833848029375076,303.31854248046875,0.0007882953505031765,0.3059927523136139,0.0006238637142814696,0.2772218585014343,0.001760927028954029,2.51957631111145,0.0004663171712309122,-0.20357070863246918,3.0465664863586426,2.6813604831695557,-0.0009555470896884799,0.27102628350257874,-0.0006696565542370081,0.5542693734169006,0.00015077866555657238,0.3379771411418915,30.938894271850586,-0.0003793543728534132,0.8794875144958496,103.72914123535156,-18.282379150390625,90.05928039550781,156.77867126464844,103.66964721679688,-112.07996368408203,61.9042854309082,1788.2620849609375,-0.01903495006263256,0.7851295471191406,-0.09384360909461975,31.274198532104492,0.03593318536877632,22.008705139160156,1016.1616821289062 +POINT (8265188.428346072 1722820.5067798109),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.11204791814088821,302.43511962890625,0.0010569439036771655,0.43030887842178345,0.001025176141411066,0.40188440680503845,-8.804628305369988e-05,2.6517224311828613,-0.0013249411713331938,-0.29616597294807434,4.112709045410156,2.169313669204712,0.000981425866484642,0.3594789505004883,0.0010734850075095892,0.6493462324142456,0.0007092743762768805,0.37973397970199585,12.84316349029541,0.00045232949196361005,0.8748148679733276,106.37291717529297,62.94661331176758,90.36048126220703,248.5903778076172,87.9568862915039,38.229251861572266,103.19638061523438,2216.14990234375,-0.009315443225204945,0.7879675626754761,-0.06045638024806976,29.376924514770508,0.05381540209054947,21.469715118408203,3440.5966796875 +POINT (8262991.047038437 1757646.8486342842),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,18.551830291748047,2328.795654296875,0.07300230115652084,14.763771057128906,-0.011170260608196259,305.1404113769531,-0.0014035082422196865,0.388773649930954,-0.0017161160940304399,0.35939082503318787,-0.0011446651769801974,2.856858253479004,0.0011644067708402872,-0.12658992409706116,3.2029500007629395,2.5971996784210205,-0.001108364900574088,0.1771734654903412,-0.00042219413444399834,0.4652484059333801,-0.0002588187635410577,0.3351559638977051,15.364158630371094,0.0008344775415025651,0.7585928440093994,100.55213928222656,41.313560485839844,83.56103515625,225.8474884033203,108.73534393310547,-92.76527404785156,87.28367614746094,2216.256103515625,-0.010062336921691895,0.7610608339309692,-0.1258036345243454,31.084882736206055,0.03559151664376259,22.250558853149414,1271.2769775390625 +POINT (8263357.983003328 1743875.7286443193),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.10894203186035,2127.662353515625,0.04621821641921997,17.30975914001465,0.1526447832584381,302.1591796875,0.0007093987660482526,0.5580284595489502,0.0005279999459162354,0.5351346731185913,0.002065878128632903,2.873239278793335,0.00010924544767476618,-0.3364294767379761,2.976552724838257,2.7044215202331543,-0.00026999067631550133,0.3948645293712616,1.5944931874400936e-05,0.6991877555847168,0.0001324988406850025,0.42298126220703125,19.64357566833496,-0.00029871624428778887,0.8567355871200562,153.84024047851562,-103.5877914428711,122.5150146484375,102.59803771972656,123.60143280029297,-177.8230743408203,110.93828582763672,2752.34375,-0.01963956467807293,0.8562390208244324,-0.02172987535595894,28.606542587280273,0.047052688896656036,21.228708267211914,3683.45751953125 +POINT (8262208.575725117 1722340.1442545843),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.07660377025604248,303.8547668457031,0.0013873365242034197,0.4027964770793915,0.001298371935263276,0.37126660346984863,0.0034248295705765486,2.805673122406006,-7.879693293944001e-05,-0.17699284851551056,3.0465664863586426,2.6813604831695557,8.304878974740859e-06,0.23076416552066803,0.0003515584103297442,0.5370743274688721,0.00021910453506279737,0.3595305383205414,2.486358880996704,-0.0004804693453479558,0.8124205470085144,106.87052154541016,109.65840911865234,86.9051742553711,288.0275573730469,85.73184967041016,28.89508056640625,122.27912902832031,2229.900634765625,-0.006978257093578577,0.7575232982635498,-0.089240662753582,30.87650489807129,0.05838431045413017,20.98579216003418,1346.8294677734375 +POINT (8268216.094035114 1699767.6163022227),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,20.098785400390625,2437.119140625,0.06117723137140274,15.88566780090332,0.05419588088989258,302.32122802734375,-0.0034292966593056917,0.586168646812439,-0.0036228422541171312,0.5623541474342346,-0.0053653595969080925,2.9337046146392822,0.0006765538710169494,-0.330517441034317,5.493683815002441,1.311958909034729,-0.0006473436369560659,0.38087964057922363,-0.0002861488610506058,0.6862678527832031,0.00013731681974604726,0.41406574845314026,12.32027530670166,0.0011977668618783355,0.8380826711654663,112.24737548828125,25.14895248413086,101.52494812011719,201.33995056152344,126.49259185791016,-132.6247100830078,114.27827453613281,2663.563232421875,-0.018778568133711815,0.8630785942077637,-0.04728643596172333,28.483383178710938,0.03317045792937279,20.61798095703125,1609.3275146484375 +POINT (8261914.391418096 1693897.497651467),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.16176170110702515,307.7324523925781,-0.0006050251540727913,0.34639212489128113,-0.0009059908334165812,0.3194117248058319,-0.002578916260972619,2.9777512550354004,0.0014604933094233274,-0.014392639510333538,3.0465664863586426,2.6813604831695557,-0.0017964572180062532,0.06376056373119354,-0.0028071298729628325,0.33474022150039673,-0.0015445156022906303,0.28870752453804016,5.705350875854492,-0.0013294877717271447,0.6591832637786865,109.04148864746094,158.64561462402344,96.4761962890625,275.09130859375,99.33989715576172,0.6827641129493713,132.5497589111328,2100.493408203125,-0.011939688585698605,0.7012676000595093,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,303.40106201171875 +POINT (8263909.235897399 1757370.1368968314),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.08149499446153641,302.8175048828125,-0.0013975020265206695,0.474925696849823,-0.0015468411147594452,0.44469207525253296,-0.002366456901654601,2.799790620803833,0.0011483229463919997,-0.2816760241985321,2.8782966136932373,2.7207159996032715,-0.0009173594298772514,0.33766844868659973,-0.0015682941302657127,0.6527922749519348,-0.0014227626379579306,0.4048529863357544,8.01537036895752,-0.0004765524936374277,0.8587448596954346,90.82323455810547,-35.93355178833008,74.20166015625,169.15623474121094,91.66905975341797,-118.74436950683594,72.75606536865234,2343.1435546875,-0.009933292865753174,0.8241186141967773,-0.036449797451496124,29.60443687438965,0.02505318634212017,21.14196014404297,730.724853515625 +POINT (8262362.489718652 1755018.4568685049),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.03142496198415756,303.45281982421875,-0.0014827440027147532,0.4383949935436249,-0.0015188012039288878,0.40593594312667847,-0.0028389994986355305,2.7554423809051514,0.0009085399797186255,-0.25706925988197327,2.8782966136932373,2.7207159996032715,-0.0007795853889547288,0.3147326707839966,-0.0013340647565200925,0.6265485882759094,-0.0010695678647607565,0.39006078243255615,6.727706432342529,-0.00010614396160235628,0.8567123413085938,132.548095703125,-114.87063598632812,108.6090316772461,105.14340209960938,116.8058853149414,-163.04998779296875,102.5054931640625,2104.55224609375,-0.013723395764827728,0.8177762031555176,-0.040492091327905655,30.01732063293457,0.02985774539411068,21.28335952758789,1373.65673828125 +POINT (8249931.350459967 1760775.636748233),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,19.382850646972656,2113.504638671875,0.04423021897673607,17.48790740966797,0.029545117169618607,302.9104919433594,-0.003613844746723771,0.5001254677772522,-0.004038905259221792,0.4735713601112366,-0.006144895683974028,2.785489082336426,0.0005488945753313601,-0.3168671429157257,2.3598642349243164,2.984099864959717,-0.0008116583921946585,0.3762702941894531,-0.0003753374039661139,0.6772353053092957,0.0001778161822585389,0.40537917613983154,16.583110809326172,0.0013689942425116897,0.8611501455307007,85.36880493164062,23.46641731262207,74.41870880126953,226.47434997558594,92.56411743164062,-96.00615692138672,87.59800720214844,2541.54345703125,-0.009508254006505013,0.8198584318161011,-0.08530356734991074,29.307207107543945,0.047548215836286545,21.594316482543945,1899.874755859375 +POINT (8269318.507690475 1707379.795696858),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,17.89788818359375,2369.10595703125,0.05740818381309509,16.241392135620117,0.06905130296945572,300.50701904296875,-0.0004007233656011522,0.41838449239730835,-0.00039439747342839837,0.3886161148548126,-0.0020033728796988726,2.611588954925537,-0.0012847593752667308,-0.3109188675880432,5.316018104553223,1.480040192604065,0.0014299986651167274,0.3690909445285797,0.0011540093692019582,0.6599560976028442,0.0003755000070668757,0.38564735651016235,23.447172164916992,0.0006030931253917515,0.8903363943099976,156.51937866210938,-63.43372344970703,118.52243041992188,153.1845245361328,124.94973754882812,-94.90625762939453,174.11500549316406,1823.7177734375,-0.014450011774897575,0.8112300634384155,-0.03806174919009209,27.451581954956055,0.041838955134153366,20.81553840637207,695.3224487304688 +POINT (8259966.1680539595 1719973.3948550809),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.05193568393588066,308.4468078613281,0.001474005519412458,0.35266345739364624,0.0011926917359232903,0.32345667481422424,-0.0014158072881400585,3.0548453330993652,-0.003435651073232293,0.012658439576625824,3.1579742431640625,2.646435260772705,0.0031487776432186365,0.036309078335762024,0.004550579469650984,0.3015143871307373,0.002224079566076398,0.2748582363128662,3.6320528984069824,0.0031466535292565823,0.6190783381462097,34.50871658325195,358.1109924316406,32.470603942871094,457.40191650390625,37.144412994384766,181.57009887695312,122.44214630126953,2211.289306640625,0.0010763374157249928,0.6843958497047424,-0.14505799114704132,33.04738998413086,0.03633972629904747,21.37674903869629,283.7911682128906 +POINT (8265817.3241057955 1751275.445958411),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,17.327150344848633,1999.3411865234375,0.05179499089717865,16.80307388305664,0.1449660211801529,301.3661804199219,-0.0007517781923525035,0.48456448316574097,-0.0008840722730383277,0.45647770166397095,-0.001572582172229886,2.738558292388916,1.0014326107921079e-05,-0.31905582547187805,2.557372570037842,2.877892017364502,6.414205563487485e-05,0.37510910630226135,-1.496169079473475e-05,0.6747738718986511,-6.448958447435871e-05,0.4017024338245392,13.997326850891113,0.0002332732838112861,0.8700960874557495,89.73117065429688,-38.852760314941406,79.18194580078125,156.68890380859375,92.74100494384766,-129.22171020507812,76.7036361694336,2286.57080078125,-0.007681361865252256,0.8217753767967224,-0.025719739496707916,29.000965118408203,0.030167387798428535,21.33575439453125,2339.03271484375 +POINT (8264088.733989524 1733604.3333529911),0.0,0.0,Mollem NP,0,,,,,,,,,,,,,,,,,,,,,16.300752639770508,2173.091796875,0.05328503996133804,16.63265609741211,0.04141964018344879,304.6920471191406,0.0007146008429117501,0.4164154529571533,0.0004973089671693742,0.3891199231147766,0.0012067289790138602,2.8180246353149414,2.3340873667621054e-05,-0.1972677856683731,3.2316770553588867,2.59718656539917,-0.00021166416991036385,0.25435540080070496,0.00023369083646684885,0.5621845126152039,0.00013777075218968093,0.37198004126548767,3.801337957382202,9.16440985747613e-05,0.8183951377868652,129.55313110351562,-62.192195892333984,112.17459869384766,130.67543029785156,112.32846069335938,-134.0764923095703,187.25869750976562,2054.917236328125,-0.01035633310675621,0.7988394498825073,-0.07374374568462372,30.790075302124023,0.027237525209784508,21.205472946166992,724.9169311523438 +POINT (8262208.467854308 1760394.0964244895),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.11348136514425278,303.02850341796875,-0.001171817071735859,0.4422684907913208,-0.0009368519531562924,0.40275269746780396,-0.0009333315538242459,2.7273383140563965,0.0004809203674085438,-0.26877641677856445,2.306614875793457,2.9972360134124756,-0.00022756030375603586,0.3246743381023407,-0.00011859893129440024,0.6291462182998657,6.225575634744018e-05,0.3839624226093292,7.389405727386475,0.0001431470736861229,0.8597451448440552,86.73094177246094,-37.36860275268555,72.25682830810547,163.1007080078125,90.2432861328125,-123.07562255859375,79.12460327148438,2201.614990234375,-0.00860116258263588,0.8227941393852234,-0.027500826865434647,29.456207275390625,0.04411881044507027,21.204824447631836,315.77777099609375 +POINT (8266781.082324734 1740243.032644107),0.0,0.0,Bhagwan Mahavir WLS,0,,,,,,,,,,,,,,,,,,,,,16.647598266601562,2113.801025390625,0.05815640464425087,16.200042724609375,0.04635683447122574,302.5574951171875,-0.000479330396046862,0.5138925313949585,-0.0005321722128428519,0.4887782633304596,-0.00063674570992589,2.860227584838867,0.0011388881830498576,-0.290946364402771,3.298588752746582,2.5584447383880615,-0.001041168114170432,0.3452199101448059,-0.0017057759687304497,0.6563661694526672,-0.001314059947617352,0.40349358320236206,18.141578674316406,-0.0010408523958176374,0.8454093337059021,150.56622314453125,-138.31390380859375,114.67355346679688,98.1435546875,124.75839233398438,-189.72776794433594,74.42705535888672,2517.97119140625,-0.020268639549613,0.8592216968536377,-0.028480077162384987,29.268930435180664,0.03891749680042267,21.047748565673828,1068.8294677734375 +POINT (8258719.379196643 1690166.7969867834),0.0,0.0,Cotigaon WLS,0,,,,,,,,,,,,,,,,,,,,,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.06939353048801422,303.7954406738281,0.0008042920380830765,0.49073249101638794,0.0007620321703143418,0.4690490663051605,0.0006981897749938071,2.830446481704712,-0.0008148807683028281,-0.2766816318035126,2.8360955715179443,2.6934564113616943,0.0005031494656577706,0.3335169553756714,0.0009802106069400907,0.639228880405426,0.000898686412256211,0.3907821476459503,6.816259384155273,0.000661966681946069,0.8397240042686462,73.50871276855469,55.9801025390625,65.16026306152344,235.34410095214844,81.47747802734375,-72.71906280517578,77.62509155273438,2507.85205078125,-0.007467234507203102,0.813981294631958,-0.1520131528377533,32.182342529296875,0.02126183547079563,21.669893264770508,94.49826049804688 +POINT (8267530.275637369 1696005.774808752),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,20.098785400390625,2437.119140625,0.06117723137140274,15.88566780090332,0.048652756959199905,300.75482177734375,0.002469591097906232,0.3750491440296173,0.002518758410587907,0.3430579900741577,-3.720133827300742e-05,2.5289952754974365,-0.0027106294874101877,-0.3244740664958954,5.493683815002441,1.311958909034729,0.0023940412793308496,0.38443702459335327,0.0015967371873557568,0.6760621666908264,0.00010003821807913482,0.39484086632728577,28.76544189453125,0.00011648180952761322,0.9113370180130005,94.86228942871094,18.513935089111328,77.31232452392578,199.25462341308594,97.6991958618164,-90.68492889404297,66.6533203125,2103.069091796875,-0.014307892881333828,0.8223002552986145,-0.06363168358802795,28.467269897460938,0.04127299040555954,20.59632682800293,942.306884765625 +POINT (8269396.12375086 1707411.5962951754),0.0,0.0,Netravali WLS,0,,,,,,,,,,,,,,,,,,,,,17.89788818359375,2369.10595703125,0.05740818381309509,16.241392135620117,0.09030213952064514,300.40728759765625,-0.0018422084394842386,0.46185967326164246,-0.0020542717538774014,0.4351554214954376,-0.0009206110262311995,2.6274142265319824,0.0013165442505851388,-0.3621266484260559,5.316018104553223,1.480040192604065,-0.0014121036510914564,0.4175746440887451,-0.0009934002300724387,0.7040761113166809,-0.00017794957966543734,0.4063299894332886,24.761465072631836,4.023347355541773e-05,0.8972964286804199,159.81736755371094,-81.84008026123047,123.23213195800781,137.86216735839844,124.17517852783203,-94.08460998535156,152.9871063232422,2074.8515625,-0.013853433541953564,0.8266860842704773,-0.03806174919009209,27.451581954956055,0.041838955134153366,20.81553840637207,640.1314086914062 +POINT (8261288.421220366 1764383.4324990925),1.73538633992,0.01879725637,Mhadei WLS,0,,,,,,,,,,,,,,,,,,,,,17.89788818359375,2369.10595703125,0.05740818381309509,16.241392135620117,0.03672073408961296,302.1248474121094,-0.0011264999629929662,0.4042935073375702,-0.0012308943551033735,0.37371692061424255,-0.003164195455610752,2.709014654159546,0.00022047852689865977,-0.19981461763381958,5.316018104553223,1.480040192604065,-0.00022042475757189095,0.2621685862541199,-0.0007491459837183356,0.5389301180839539,-0.00082622334593907,0.3270781338214874,10.999146461486816,0.00012400042032822967,0.8161163330078125,119.37775421142578,-46.1629524230957,95.22669982910156,134.25672912597656,108.48634338378906,-150.4351043701172,80.70905303955078,1998.132080078125,-0.011447099968791008,0.7802364230155945,-0.051267534494400024,27.999706268310547,0.02773132734000683,19.967836380004883,3466.9921875 +POINT (8259151.094928642 1759902.4229665336),,,,3,297.82,334.69,726.0,4.47,36.87,26-04-2018,n,0.62,VIIRS,0,1,3.0,D,N,0.72,High Risk,,,,High Risk,15.485177040100098,2064.32275390625,0.0439036525785923,17.53630256652832,0.7669578194618225,301.8624572753906,-0.0064977118745446205,0.5277328491210938,-0.010136762633919716,0.509669303894043,0.0031544873490929604,2.8359766006469727,0.014721804298460484,-0.330281525850296,2.306614875793457,2.9972360134124756,-0.015560828149318695,0.3936383128166199,-0.018735386431217194,0.7022067308425903,-0.009695516899228096,0.41956275701522827,21.142011642456055,-0.01110907457768917,0.8675874471664429,157.03770446777344,60.39256286621094,118.4527359008789,288.4013366699219,121.1714859008789,-23.97451400756836,136.1756591796875,2629.950927734375,-0.020824026316404343,0.8091909289360046,-0.02419283241033554,29.31756019592285,0.037311919033527374,21.634313583374023,1838.1898193359375 +POINT (8259771.079617116 1724759.3967803975),,,,3,300.19,335.37,738.0,2.3,35.18,06-04-2013,n,0.38,VIIRS,0,1,3.0,D,N,0.59,High Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.1590551733970642,307.9532775878906,-0.00139885104727,0.3201126456260681,-0.001422568573616445,0.2932116985321045,-0.00016246738960035145,2.985119104385376,0.003261376405134797,0.030697975307703018,3.0465664863586426,2.6813604831695557,-0.0036697599571198225,0.014680464752018452,-0.005007404368370771,0.2700957953929901,-0.001958254026249051,0.266215056180954,7.6590070724487305,-0.003128026146441698,0.6136714816093445,102.89124298095703,189.32144165039062,90.41915893554688,295.8944091796875,99.33528137207031,2.158346652984619,116.88705444335938,2020.793701171875,-0.010756300762295723,0.6754152178764343,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,325.7350158691406 +POINT (8255210.295535699 1757437.9015250085),,,,3,309.35,367.0,751.0,17.63,57.65,16-04-2013,h,0.47,VIIRS,0,1,3.0,D,N,0.48,High Risk,,,,High Risk,17.40591049194336,2074.81591796875,0.0439036525785923,17.53630256652832,0.25495290756225586,309.116455078125,-0.0015410155756399035,0.3733777701854706,-0.0025193174369633198,0.3429637551307678,-0.0076751746237277985,3.000619649887085,-0.00023479355149902403,-0.03199981898069382,3.006338357925415,2.7003719806671143,-3.9574781112605706e-05,0.07839220017194748,0.00036779619404114783,0.3396512567996979,-0.0007775118574500084,0.28751593828201294,1.7596813440322876,0.0029018819332122803,0.6433212161064148,89.44823455810547,153.8129119873047,75.77940368652344,307.91851806640625,97.70325469970703,-32.07685852050781,89.23446655273438,2545.909912109375,-0.00813055969774723,0.7351407408714294,-0.10466708987951279,32.834415435791016,0.03671526536345482,20.826221466064453,57.63419723510742 +POINT (8257641.58857344 1693835.5424770226),,,,3,301.31,350.13,751.0,10.45,48.82,16-04-2013,n,0.48,VIIRS,0,1,3.0,D,N,0.48,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,-0.026984261348843575,304.89801025390625,0.0015507313655689359,0.5162158608436584,0.001270474400371313,0.4865513741970062,-0.00266092992387712,3.0106756687164307,-0.0029702375177294016,-0.2050039917230606,2.8360955715179443,2.6934564113616943,0.0028836247511208057,0.26075151562690735,0.0030207557138055563,0.5602060556411743,0.0011093615321442485,0.35412904620170593,25.55927276611328,0.0019285830203443766,0.7619333863258362,154.71868896484375,80.07776641845703,144.57058715820312,207.3734130859375,140.000732421875,-15.344822883605957,136.3647003173828,2740.998779296875,-0.012878349050879478,0.7793567776679993,-0.12909908592700958,30.380321502685547,0.031377870589494705,21.596834182739258,2892.287109375 +POINT (8255245.042475806 1757954.28568843),,,,3,302.64,343.92,751.0,6.39,41.28,16-04-2013,n,0.47,VIIRS,0,1,3.0,D,N,0.48,High Risk,,,,High Risk,17.40591049194336,2074.81591796875,0.0439036525785923,17.53630256652832,0.09556286782026291,304.7933044433594,-0.002768457867205143,0.4860532283782959,-0.003095421474426985,0.4563058614730835,-0.005470718257129192,2.976832151412964,0.0002314443700015545,-0.19571593403816223,3.006338357925415,2.7003719806671143,4.5566059270640835e-05,0.24657617509365082,0.0006265992415137589,0.5565924048423767,9.736731590237468e-05,0.37105804681777954,6.487612724304199,0.0017035076161846519,0.7827280163764954,93.10492706298828,18.387535095214844,84.1129150390625,212.8773651123047,101.9572982788086,-111.40953826904297,114.37515258789062,2613.04638671875,-0.008225029334425926,0.8091617822647095,-0.1069658026099205,32.359535217285156,0.04121944308280945,20.958009719848633,182.7649383544922 +POINT (8263410.077015991 1747221.264555977),,,,3,300.27,356.84,757.0,8.58,56.57,16-04-2017,n,0.39,VIIRS,0,1,3.0,D,N,0.44,High Risk,,,,High Risk,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.15995974838733673,301.47900390625,0.0005496047670021653,0.40370118618011475,0.0004654083459172398,0.37241455912590027,0.0027627097442746162,2.608217239379883,0.0010380593594163656,-0.3040908873081207,2.976552724838257,2.7044215202331543,-0.0009365169680677354,0.36261868476867676,-0.0006842448492534459,0.6577442288398743,-8.381297084270045e-05,0.3892545998096466,19.405414581298828,-0.0008653072291053832,0.8905579447746277,107.9455337524414,-44.79071807861328,96.26102447509766,131.95774841308594,115.38044738769531,-155.48817443847656,116.62018585205078,1955.7725830078125,-0.01419547013938427,0.8339504599571228,-0.009360027499496937,30.074121475219727,0.03362371772527695,21.575223922729492,1249.520751953125 +POINT (8263312.289198837 1747358.2886353752),,,,3,301.04,356.42,757.0,12.1,55.38,16-04-2017,n,0.39,VIIRS,0,1,3.0,D,N,0.44,High Risk,,,,High Risk,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.36348646879196167,302.61474609375,-0.005507180467247963,0.41126346588134766,-0.006973599083721638,0.38455930352211,0.013105081394314766,2.6685433387756348,0.01754899136722088,-0.24737334251403809,2.976552724838257,2.7044215202331543,-0.018594350665807724,0.3068135678768158,-0.02038157358765602,0.5888617038726807,-0.008279030211269855,0.36349794268608093,17.001943588256836,-0.011784297414124012,0.8463740348815918,93.1970443725586,101.45000457763672,91.06293487548828,197.44107055664062,107.7288818359375,-100.27291107177734,154.4427947998047,1719.7645263671875,0.0016844321507960558,0.6863299012184143,-0.009360027499496937,30.074121475219727,0.03362371772527695,21.575223922729492,1130.676025390625 +POINT (8261440.421896807 1709783.7415948452),,,,3,298.95,340.13,759.0,5.8,41.18,29-04-2016,n,0.39,VIIRS,0,1,3.0,D,N,0.44,High Risk,,,,High Risk,18.551830291748047,2328.795654296875,0.07300230115652084,14.763771057128906,0.06262639164924622,305.5518493652344,-0.00197249255143106,0.47168999910354614,-0.0024339198134839535,0.4384525418281555,-0.0017665178747847676,2.9765632152557373,0.002646655309945345,-0.17915673553943634,3.2029500007629395,2.5971996784210205,-0.003318768460303545,0.23716731369495392,-0.003525286912918091,0.5374695062637329,-0.001169952447526157,0.35188037157058716,27.420276641845703,-0.0008250356186181307,0.7608859539031982,88.34839630126953,59.61085510253906,73.06415557861328,231.9917449951172,92.5712890625,-75.19615173339844,96.73827362060547,2508.031005859375,-0.010235882364213467,0.7951149344444275,-0.08863598108291626,29.770793914794922,0.047402273863554,22.076128005981445,1158.7745361328125 +POINT (8263651.320057303 1753134.1062815154),,,,3,302.81,344.02,804.0,5.12,41.21,11-04-2019,n,0.48,VIIRS,0,1,3.0,D,N,0.4,High Risk,,,,High Risk,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.12125486880540848,304.7938537597656,0.0010932032018899918,0.18420721590518951,0.0008884186972863972,0.1550678312778473,0.0016681865090504289,2.34515380859375,0.0009120293543674052,-0.14587877690792084,2.8782966136932373,2.7207159996032715,-0.0009523048647679389,0.23871098458766937,-0.0013114236062392592,0.4841683804988861,-0.0007654520450159907,0.28166088461875916,11.788640975952148,-0.0007417494198307395,0.9040300250053406,39.516151428222656,301.0746154785156,27.443439483642578,437.2550964355469,31.633943557739258,208.7972869873047,5.757008075714111,1537.91796875,-0.028733540326356888,0.6486642360687256,-0.04985617846250534,29.66597557067871,0.025595787912607193,21.466461181640625,1040.6807861328125 +POINT (8265464.613946008 1724506.1927953858),,,,3,301.49,339.53,805.0,3.92,38.04,18-04-2016,n,0.48,VIIRS,0,1,3.0,D,N,0.4,High Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.15402798354625702,304.0484924316406,-0.0036089099012315273,0.3763316571712494,-0.004025021567940712,0.34976404905319214,-0.002492892323061824,2.791931390762329,0.003328492632135749,-0.1307675540447235,4.112709045410156,2.169313669204712,-0.003592612687498331,0.18779253959655762,-0.002857908606529236,0.46172988414764404,-0.0007548993453383446,0.32273057103157043,16.571483612060547,0.000462677184259519,0.7649527192115784,119.5983657836914,95.7073745727539,103.38448333740234,240.81298828125,100.76727294921875,6.13048791885376,120.49285888671875,2060.905029296875,-0.012358473613858223,0.7385162711143494,-0.0697527602314949,30.34874725341797,0.046747997403144836,21.356609344482422,2612.2568359375 +POINT (8260731.584318634 1760555.9609646623),,,,3,297.88,338.95,810.0,4.41,41.07,29-04-2018,l,0.41,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.13808783888816833,302.95904541015625,-0.00798909179866314,0.6008435487747192,-0.008251074701547623,0.5688269138336182,-0.0024054080713540316,2.951946496963501,0.007960178889334202,-0.3415275812149048,2.306614875793457,2.9972360134124756,-0.007375592365860939,0.38895854353904724,-0.0074590458534657955,0.7004734873771667,-0.003588935825973749,0.426931768655777,4.368103504180908,-0.0027646953240036964,0.8445484638214111,93.49852752685547,32.86114501953125,81.61992645263672,239.01626586914062,96.40020751953125,-56.03996276855469,73.20800018310547,2898.6025390625,-0.010638643987476826,0.8308727741241455,-0.031189966946840286,29.349414825439453,0.03881462663412094,21.18943214416504,931.302978515625 +POINT (8260796.610735117 1760162.186700102),,,,3,298.45,334.53,810.0,3.51,36.08,29-04-2018,l,0.41,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.045347440987825394,303.9613037109375,0.0008926673326641321,0.5871001482009888,0.0016995895421132445,0.5450079441070557,-0.0016846206272020936,3.0193779468536377,-0.003415928455069661,-0.280801385641098,2.306614875793457,2.9972360134124756,0.0037261920515447855,0.32888227701187134,0.004440821707248688,0.6371090412139893,0.0028781467117369175,0.39223286509513855,8.75849437713623,0.0029877449851483107,0.7989221215248108,76.17213439941406,176.0155487060547,66.82545471191406,355.1171875,83.54419708251953,40.02505874633789,85.0496597290039,2948.9345703125,-0.004669887013733387,0.8003960251808167,-0.0301418025046587,29.389135360717773,0.04379437491297722,21.15009307861328,802.3930053710938 +POINT (8265707.346141895 1693212.5917996406),,,,3,293.65,333.07,810.0,5.32,39.42,29-04-2018,n,0.41,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,21.10080909729004,2478.678955078125,0.06601659208536148,15.423352241516113,-0.008190172724425793,305.96002197265625,0.0012024900643154979,0.3457084596157074,0.0002592938544694334,0.3261076509952545,-0.0031317980028688908,3.123504877090454,-0.000396743300370872,0.03130745515227318,5.156741619110107,1.4496335983276367,-0.0007564517436549067,0.03115919604897499,-0.00083976611495018,0.28704512119293213,-0.00033485121093690395,0.2624029815196991,24.580829620361328,0.0010267950128763914,0.5665770769119263,131.39210510253906,340.1015625,110.15463256835938,430.2791442871094,118.87774658203125,84.5316390991211,79.86336517333984,2728.86572265625,-0.0200811754912138,0.7167363166809082,-0.08062753081321716,29.24935531616211,0.02844085544347763,20.57973861694336,1092.3170166015625 +POINT (8265278.46962401 1693142.1767506842),,,,3,293.3,334.08,810.0,3.37,40.78,29-04-2018,n,0.41,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.05650223046541214,303.9241943359375,-0.0003618040063884109,0.5089510083198547,-0.0005711097037419677,0.4834989905357361,-0.0012240340001881123,2.8107993602752686,-0.0005812531453557312,-0.30068933963775635,5.156741619110107,1.4496335983276367,0.00041711379890330136,0.3652467429637909,0.0007519519422203302,0.6579996347427368,0.0006055821431800723,0.3874170780181885,18.83531379699707,0.0007618158706463873,0.8434931039810181,161.01174926757812,83.86126708984375,127.25291442871094,257.4933166503906,136.08660888671875,-61.496498107910156,119.26997375488281,2622.40625,-0.019422242417931557,0.8192311525344849,-0.07518620789051056,28.91219139099121,0.032185424119234085,20.424049377441406,1115.2406005859375 +POINT (8270629.002015562 1711402.8978732822),,,,3,304.7,350.69,811.0,10.72,45.99,06-03-2016,n,0.41,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,17.89788818359375,2369.10595703125,0.05740818381309509,16.241392135620117,-0.04867115989327431,306.4007873535156,-0.001577236340381205,0.2906107008457184,-0.0020980616100132465,0.2676093578338623,0.0010608976008370519,2.8372790813446045,0.0033111139200627804,0.04553511366248131,5.316018104553223,1.480040192604065,-0.0045846495777368546,0.00885898806154728,-0.004468242172151804,0.2223745882511139,-0.000665093946736306,0.22271199524402618,6.359875202178955,-0.0013048918917775154,0.5965570211410522,116.25569152832031,125.87451171875,96.46175384521484,247.99388122558594,108.8900375366211,-67.20293426513672,89.5888442993164,2178.043212890625,-0.010797621682286263,0.6979422569274902,-0.05125878378748894,28.37356948852539,0.03358734771609306,20.72114372253418,3193.325439453125 +POINT (8260361.281214069 1709551.2667483645),,,,3,302.56,338.29,816.0,2.11,35.73,05-04-2019,n,0.39,VIIRS,3,1,3.0,D,N,0.36,High Risk,,,,High Risk,18.551830291748047,2328.795654296875,0.07300230115652084,14.763771057128906,0.060644831508398056,305.2375793457031,-4.889090519100137e-07,0.4280981123447418,-0.0003642725932877511,0.3951316773891449,0.00353896408341825,2.8224399089813232,0.0018546973587945104,-0.19758082926273346,3.2029500007629395,2.5971996784210205,-0.0022855508141219616,0.25687870383262634,-0.0015783734852448106,0.5514596104621887,-0.0001045042445184663,0.35632574558258057,14.330892562866211,-0.0007982212700881064,0.8021501898765564,23.415563583374023,321.58502197265625,19.904775619506836,463.5007629394531,23.839338302612305,218.78384399414062,61.64956283569336,2420.434326171875,-0.006453705485910177,0.7617949843406677,-0.07298747450113297,29.364107131958008,0.027333280071616173,23.170211791992188,1647.9207763671875 +POINT (8261704.498641618 1758671.676354439),,,,3,304.64,351.0,816.0,7.23,46.36,21-04-2019,n,0.38,VIIRS,0,1,3.0,D,N,0.36,High Risk,,,,High Risk,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.16143712401390076,306.2485656738281,-8.699404133949429e-05,0.4235208034515381,-0.0005024212878197432,0.3859908878803253,-0.004900583066046238,2.8202342987060547,-0.002981927478685975,-0.1864607334136963,2.8782966136932373,2.7207159996032715,0.002728368854150176,0.24414359033107758,0.0033994298428297043,0.542648196220398,0.0018022186122834682,0.3483739495277405,8.41389274597168,0.0027686257380992174,0.8046412467956543,4.624422073364258,319.19287109375,3.6907434463500977,462.0476379394531,5.454146385192871,231.032470703125,39.782135009765625,2322.42236328125,0.001021283445879817,0.7543058395385742,-0.04044312611222267,29.833984375,0.03883366286754608,21.0154972076416,599.9573364257812 +POINT (8264963.265238756 1696645.1846182232),,,,3,294.87,335.88,822.0,3.12,41.01,25-03-2015,n,0.39,VIIRS,0,1,3.0,D,N,0.36,High Risk,,,,High Risk,21.53333282470703,2424.092041015625,0.07109512388706207,14.932489395141602,0.030272740870714188,302.5074768066406,0.0002969462366309017,0.42880919575691223,9.34655690798536e-05,0.39965328574180603,0.00010308095079381019,2.6573646068573,-0.0003053356194868684,-0.2981160879135132,5.493683815002441,1.311958909034729,-0.00010682357242330909,0.3565613329410553,0.00029675979749299586,0.6530452370643616,0.0005587598425336182,0.38715648651123047,23.50609588623047,0.0003656749613583088,0.8782176971435547,91.0837173461914,-5.189761638641357,78.75733184814453,179.66094970703125,93.6447982788086,-107.00601959228516,67.77201843261719,2179.99609375,-0.009828880429267883,0.8165248036384583,-0.07156074792146683,29.077322006225586,0.03938012197613716,21.203235626220703,797.048095703125 +POINT (8259632.588241548 1692459.1098427165),,,,3,298.52,344.62,823.0,8.2,46.1,09-05-2018,n,0.39,VIIRS,0,1,3.0,D,N,0.36,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.25299620628356934,302.77972412109375,-0.004684533458203077,0.4208238124847412,-0.004691168200224638,0.3903476893901825,0.030100535601377487,2.618131160736084,0.02557196095585823,-0.3008679747581482,2.8360955715179443,2.6934564113616943,-0.027217121794819832,0.36584290862083435,-0.030280569568276405,0.6558443307876587,-0.009945501573383808,0.37961339950561523,16.15848159790039,-0.022507870569825172,0.886866569519043,141.042236328125,250.61968994140625,115.0765380859375,290.7892150878906,122.67909240722656,-37.4490966796875,193.03305053710938,2195.665771484375,-0.011108418926596642,0.7331947088241577,-0.05248381569981575,29.330591201782227,0.029538217931985855,21.792821884155273,1905.299072265625 +POINT (8259973.108254592 1692905.234161697),,,,3,297.11,335.89,823.0,3.53,38.78,09-05-2018,n,0.39,VIIRS,0,1,3.0,D,N,0.36,High Risk,,,,High Risk,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.15214569866657257,301.9712829589844,0.0007108133286237717,0.5325073599815369,0.00022391893435269594,0.5144968628883362,-0.0012480417499318719,2.79940128326416,-0.0010423216735944152,-0.3459997773170471,2.8360955715179443,2.6934564113616943,0.0007435271982103586,0.40389251708984375,0.0005146305775269866,0.702666699886322,-3.2568273127253633e-06,0.41872715950012207,13.646784782409668,0.0002294825972057879,0.8687361478805542,145.15863037109375,55.37240219116211,118.22756958007812,184.6357421875,135.54141235351562,-166.64263916015625,126.13239288330078,2686.81982421875,-0.014248906634747982,0.8182864785194397,-0.05248381569981575,29.330591201782227,0.029538217931985855,21.792821884155273,2135.023193359375 +POINT (8256644.351392382 1723665.8010245813),,,,3,298.78,334.39,823.0,3.06,35.61,03-12-2018,n,0.4,VIIRS,0,1,3.0,D,N,0.37,High Risk,,,,High Risk,19.745206832885742,2261.209228515625,0.06798024475574493,15.237241744995117,0.013782313093543053,306.9048767089844,-0.002365390071645379,0.426592618227005,-0.0026836826000362635,0.40020808577537537,-0.004214835353195667,2.915229320526123,0.0005832083988934755,-0.1475318819284439,3.0465664863586426,2.6813604831695557,-0.00016262714052572846,0.19837453961372375,3.4910484828287736e-05,0.50401371717453,-0.00028003143961541355,0.3516034781932831,5.356235504150391,0.0010350196389481425,0.7759370803833008,100.90730285644531,109.3638916015625,68.9222640991211,299.1322326660156,66.55096435546875,29.092041015625,142.37632751464844,2187.4111328125,-0.006572297774255276,0.7543508410453796,-0.19462889432907104,34.09711837768555,0.029871318489313126,21.55828857421875,330.2019958496094 +POINT (8261062.673019364 1760098.791716744),,,,3,298.08,339.8,829.0,3.5,41.72,28-04-2018,n,0.44,VIIRS,0,1,3.0,D,N,0.39,High Risk,,,,High Risk,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.03777959570288658,304.1520080566406,0.0006314676138572395,0.4967663884162903,0.00083946279482916,0.4570050537586212,-3.996360464952886e-05,3.0166451930999756,-0.0018933932296931744,-0.188356414437294,2.306614875793457,2.9972360134124756,0.0020206314511597157,0.23700091242790222,0.00303904851898551,0.5503965020179749,0.0018738353392109275,0.3657313585281372,15.850967407226562,0.002310830866917968,0.7681255340576172,84.9875717163086,48.49900436401367,76.79834747314453,229.00830078125,88.90613555908203,-65.05560302734375,120.24674224853516,2717.59375,-0.005849795415997505,0.8120705485343933,-0.0301418025046587,29.389135360717773,0.04379437491297722,21.15009307861328,601.2744140625 +POINT (8259805.826557222 1711285.1093660195),,,,3,304.0,340.93,829.0,6.44,36.93,01-05-2019,n,0.44,VIIRS,3,1,3.0,D,N,0.38,High Risk,,,,High Risk,19.691659927368164,2364.66357421875,0.07300230115652084,14.763771057128906,0.006308240350335836,305.3353271484375,0.001706594368442893,0.39594724774360657,0.0015330614987760782,0.36499515175819397,0.003505144501104951,2.756302833557129,-0.0008873485494405031,-0.18769808113574982,3.2029500007629395,2.5971996784210205,0.0006194214802235365,0.24801968038082123,0.0011549275368452072,0.5426624417304993,0.0008152362424880266,0.350797563791275,5.906496047973633,-0.00027346936985850334,0.8184866309165955,89.28316497802734,75.49959564208984,76.40766906738281,258.9079284667969,95.46259307861328,-47.35544204711914,119.25712585449219,2114.77734375,-0.007252242416143417,0.7523935437202454,-0.10470126569271088,30.42892837524414,0.013817660510540009,23.019588470458984,1303.900390625 +POINT (8259342.699484087 1693136.522996376),,,,3,297.36,340.84,841.0,4.34,43.48,11-05-2019,n,0.43,VIIRS,0,1,3.0,D,N,0.46,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.06683550029993057,302.0777587890625,0.0013103339588269591,0.413425087928772,0.0013356978306546807,0.3814774453639984,0.00027860666159540415,2.7104604244232178,-0.0014232253888621926,-0.2410542219877243,2.8360955715179443,2.6934564113616943,0.0013399613089859486,0.29882457852363586,0.0013748474884778261,0.5958943367004395,0.00047978360089473426,0.36658284068107605,18.806365966796875,0.00042661154293455184,0.8458729386329651,185.32073974609375,0.08389056473970413,148.38909912109375,134.0664520263672,159.64744567871094,-197.73141479492188,139.12522888183594,2299.924072265625,-0.020888660103082657,0.803833544254303,-0.05560861900448799,28.85946273803711,0.04370218515396118,21.37003517150879,2584.614013671875 +POINT (8260807.03481715 1722764.7153012494),,,,3,298.5,346.01,848.0,8.49,47.51,24-01-2019,n,0.56,VIIRS,0,1,3.0,D,N,0.52,High Risk,,,,High Risk,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,-0.00012305413838475943,311.76422119140625,-0.0026709444355219603,0.2667635679244995,-0.0032252133823931217,0.24400489032268524,-0.0005058298702351749,2.8721871376037598,0.005508885718882084,0.07047366350889206,3.0465664863586426,2.6813604831695557,-0.006504959426820278,-0.03495036065578461,-0.0077024041675031185,0.17362716794013977,-0.0024815888609737158,0.22262296080589294,2.926877975463867,-0.0045335981994867325,0.5718657374382019,113.61061096191406,216.0825958251953,92.16194152832031,331.8977966308594,101.19062805175781,38.67289733886719,124.97333526611328,1924.362548828125,-0.01422599796205759,0.6409368515014648,-0.1320013552904129,32.22622299194336,0.053101539611816406,21.09434700012207,675.859375 +POINT (8269754.371894593 1725771.7245967574),,,,3,293.7,334.58,854.0,2.39,40.88,16-04-2018,n,0.36,VIIRS,0,1,3.0,D,N,0.57,High Risk,,,,High Risk,18.239013671875,2170.728271484375,0.06290382146835327,15.734601974487305,0.2927323579788208,304.2563171386719,-0.009091012179851532,0.4445735812187195,-0.009595478884875774,0.40804386138916016,0.008942540735006332,2.8442318439483643,0.018644550815224648,-0.20367811620235443,4.112709045410156,2.169313669204712,-0.020016077905893326,0.25448235869407654,-0.023711778223514557,0.5598593354225159,-0.008383110165596008,0.363545686006546,12.042113304138184,-0.013762478716671467,0.8082695603370667,190.4233856201172,-225.75588989257812,169.46192932128906,-39.2247314453125,187.57595825195312,-342.02520751953125,209.06040954589844,1830.2293701171875,-0.014182768762111664,0.7530796527862549,-0.05031008645892143,29.528995513916016,0.04081854596734047,21.123750686645508,714.0953979492188 +POINT (8262433.191614139 1755904.791185103),,,,3,299.84,337.05,854.0,5.1,37.21,19-04-2019,n,0.35,VIIRS,0,1,3.0,D,N,0.57,High Risk,,,,High Risk,14.390942573547363,2018.94677734375,0.0439036525785923,17.53630256652832,0.05687831714749336,302.2974853515625,-0.0009538127924315631,0.4527531564235687,-0.000970649067312479,0.4237654209136963,-0.0015123983612284064,2.7447609901428223,0.0011137761175632477,-0.27618148922920227,2.8782966136932373,2.7207159996032715,-0.0009324189741164446,0.33448103070259094,-0.0015613021096214652,0.6401612758636475,-0.0013293352676555514,0.39100152254104614,8.204132080078125,-0.0006304684211499989,0.861534833908081,94.3589096069336,-26.452163696289062,81.38701629638672,172.44970703125,97.27114868164062,-116.903564453125,89.004638671875,2305.899658203125,-0.010728598572313786,0.8157629370689392,-0.04357699304819107,29.851598739624023,0.02662798762321472,21.143871307373047,577.8545532226562 +POINT (8264959.2941598855 1734159.1596791854),,,,3,299.1,335.96,855.0,2.49,36.86,25-03-2016,n,0.35,VIIRS,0,1,3.0,D,N,0.57,High Risk,,,,High Risk,16.300752639770508,2173.091796875,0.05328503996133804,16.63265609741211,0.08311744034290314,307.2726135253906,1.598159724380821e-05,0.35455119609832764,-0.0003264515253249556,0.32171350717544556,-0.001953464699909091,2.927485227584839,-0.0010137929348275065,-0.037232089787721634,3.298588752746582,2.5584447383880615,0.0003755649668164551,0.08805225044488907,0.001480843173339963,0.35683029890060425,0.001387083437293768,0.2852901816368103,5.180638313293457,0.0026825314853340387,0.6797186732292175,126.26046752929688,25.516143798828125,113.95465087890625,161.3827667236328,117.74287414550781,-107.84561920166016,155.04196166992188,1944.988037109375,-0.008643073961138725,0.7303717136383057,-0.07374374568462372,30.790075302124023,0.027237525209784508,21.205472946166992,880.5986328125 +POINT (8264957.805005309 1734168.4269043705),,,,3,299.29,337.34,855.0,2.63,38.05,25-03-2016,n,0.35,VIIRS,0,1,3.0,D,N,0.57,High Risk,,,,High Risk,16.300752639770508,2173.091796875,0.05328503996133804,16.63265609741211,0.08311744034290314,307.2726135253906,1.598159724380821e-05,0.35455119609832764,-0.0003264515253249556,0.32171350717544556,-0.001953464699909091,2.927485227584839,-0.0010137929348275065,-0.037232089787721634,3.298588752746582,2.5584447383880615,0.0003755649668164551,0.08805225044488907,0.001480843173339963,0.35683029890060425,0.001387083437293768,0.2852901816368103,5.180638313293457,0.0026825314853340387,0.6797186732292175,126.26046752929688,25.516143798828125,113.95465087890625,161.3827667236328,117.74287414550781,-107.84561920166016,155.04196166992188,1944.988037109375,-0.008643073961138725,0.7303717136383057,-0.07374374568462372,30.790075302124023,0.027237525209784508,21.205472946166992,880.5986328125 +POINT (8258117.125268042 1694085.343965488),,,,3,297.33,333.29,900.0,2.28,35.96,17-03-2017,n,0.44,VIIRS,0,1,3.0,D,N,0.63,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.04236621409654617,303.0426330566406,0.0009453444508835673,0.43131324648857117,0.000825426250230521,0.3990192413330078,-0.0027696688193827868,2.7809865474700928,-0.0022212716285139322,-0.22439457476139069,2.8360955715179443,2.6934564113616943,0.002036413410678506,0.283450722694397,0.0017252675024792552,0.5844491124153137,0.00032147965976037085,0.3635954260826111,9.896735191345215,0.0009644990786910057,0.8284740447998047,211.927734375,-233.46348571777344,158.6210479736328,8.403436660766602,168.9033966064453,-290.9312744140625,147.666748046875,2229.064208984375,-0.025027941912412643,0.8116291165351868,-0.07800664007663727,28.792545318603516,0.04635695368051529,21.41191291809082,2476.64599609375 +POINT (8258036.710920938 1694020.0663767403),,,,3,297.55,335.54,900.0,2.66,37.99,17-03-2017,n,0.44,VIIRS,0,1,3.0,D,N,0.63,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.08671767264604568,305.72955322265625,-0.0007900563650764525,0.3637315630912781,-0.0018247239058837295,0.33382371068000793,-0.007392263039946556,2.7907512187957764,0.0008138392586261034,-0.10237075388431549,2.8360955715179443,2.6934564113616943,-0.002248421311378479,0.16763274371623993,-0.004288016818463802,0.43348562717437744,-0.0025903950445353985,0.295259565114975,13.529128074645996,-0.0009081210591830313,0.7472167611122131,219.10531616210938,-177.02210998535156,185.2978973388672,-8.014030456542969,193.18162536621094,-317.11895751953125,146.66859436035156,2153.4287109375,-0.02708415314555168,0.7727397084236145,-0.09457297623157501,29.16918182373047,0.037218090146780014,21.435815811157227,2618.20458984375 +POINT (8257126.837475005 1693936.7991529757),,,,3,302.38,367.0,900.0,8.92,64.62,04-03-2018,h,0.44,VIIRS,0,1,3.0,D,N,0.62,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,-0.0934850201010704,306.5937805175781,0.0011061504483222961,0.2968420088291168,-2.3457809220417403e-05,0.283539742231369,0.0019903925713151693,2.9541053771972656,0.00024203964858315885,0.038358185440301895,2.8360955715179443,2.6934564113616943,-0.0014800692442804575,0.030322832986712456,0.0003001599106937647,0.25455671548843384,0.0014122197171673179,0.23563073575496674,31.014183044433594,0.000799694680608809,0.5956273674964905,171.6055450439453,190.4342803955078,146.17601013183594,275.2764892578125,142.08518981933594,30.147920608520508,108.20414733886719,2425.565185546875,-0.02198018692433834,0.7031614780426025,-0.12909908592700958,30.380321502685547,0.031377870589494705,21.596834182739258,2367.3623046875 +POINT (8257143.21817534 1693982.5446916055),,,,3,302.11,367.0,900.0,9.27,64.89,04-03-2018,h,0.44,VIIRS,0,1,3.0,D,N,0.62,High Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,-0.058266010135412216,306.2874450683594,0.0011667582439258695,0.2932732403278351,0.00032491315505467355,0.27921849489212036,0.004403115715831518,2.9170610904693604,0.0008459074306301773,0.03877004608511925,2.8360955715179443,2.6934564113616943,-0.002135888207703829,0.026313085108995438,4.613206328940578e-06,0.2530391812324524,0.0016426816582679749,0.23977936804294586,20.3516845703125,0.00046911652316339314,0.6105601191520691,174.99473571777344,224.89627075195312,144.77203369140625,300.4945373535156,138.85244750976562,57.725852966308594,124.1617660522461,2329.181884765625,-0.02095108851790428,0.670206606388092,-0.10779565572738647,29.633020401000977,0.03498142585158348,21.497482299804688,2396.050048828125 +POINT (8263513.821451453 1725882.8928198935),,,,3,299.75,338.38,900.0,8.55,38.63,20-03-2018,n,0.45,VIIRS,0,1,3.0,D,N,0.63,High Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.22098572552204132,313.837890625,-0.0019463226199150085,0.26039358973503113,-0.0021607279777526855,0.232496976852417,0.004930696915835142,2.8619236946105957,0.004801027476787567,0.06886192411184311,3.0465664863586426,2.6813604831695557,-0.006126275286078453,-0.028332827612757683,-0.006512750405818224,0.2134336531162262,-0.0009147536475211382,0.24664585292339325,7.255768775939941,-0.0032349845860153437,0.6353582143783569,123.58158111572266,286.4853515625,87.26092529296875,452.56353759765625,106.0225601196289,116.54203033447266,84.79956817626953,1926.6168212890625,-0.020204348489642143,0.6162902116775513,-0.10097651928663254,32.9168586730957,0.03997281938791275,21.34426498413086,1310.46435546875 +POINT (8260474.953346704 1692839.4457349987),,,,3,301.72,336.78,810.0,5.39,35.06,15-03-2019,n,0.41,VIIRS,0,1,1.0,D,N,0.37,Low Risk,,,,High Risk,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,0.05937211588025093,301.96502685546875,0.0014667330542579293,0.4448661208152771,0.0016351545928046107,0.41852545738220215,-0.00018382012785878032,2.664808511734009,-0.0028333121445029974,-0.3063919246196747,2.8360955715179443,2.6934564113616943,0.0022741924040019512,0.3700748085975647,0.0028053384739905596,0.6585643887519836,0.0021715781185775995,0.3816904127597809,27.656890869140625,0.0013535136822611094,0.8734142184257507,170.21180725097656,-18.4632625579834,147.85638427734375,132.1824188232422,162.1001434326172,-190.08726501464844,142.36245727539062,2138.1376953125,-0.019585730507969856,0.810249388217926,-0.05248381569981575,29.330591201782227,0.029538217931985855,21.792821884155273,1851.169677734375 +POINT (8255336.873674657 1757447.6931361586),,,,3,307.04,348.45,751.0,11.82,41.41,16-04-2013,n,0.47,VIIRS,0,1,2.0,D,N,0.48,Moderate Risk,,,,High Risk,17.40591049194336,2074.81591796875,0.0439036525785923,17.53630256652832,0.14065667986869812,308.1080017089844,-0.001716605038382113,0.4141395390033722,-0.002478592097759247,0.38111451268196106,-0.013009009882807732,3.0417320728302,-0.0028097883332520723,-0.07306268066167831,3.006338357925415,2.7003719806671143,0.002877117833122611,0.12042617797851562,0.004383511375635862,0.399059534072876,0.0009993977146223187,0.3100510835647583,3.617776393890381,0.006949680391699076,0.6737844944000244,89.58692169189453,98.87937927246094,80.56713104248047,264.61767578125,98.05528259277344,-64.78831481933594,94.866943359375,2557.598876953125,-0.0073540392331779,0.7604257464408875,-0.10466708987951279,32.834415435791016,0.03671526536345482,20.826221466064453,211.67398071289062 +POINT (8259470.270392764 1724750.6478179535),,,,3,307.71,343.55,757.0,7.46,35.84,21-04-2013,n,0.57,VIIRS,0,1,2.0,D,N,0.43,Moderate Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.08568906038999557,306.78179931640625,0.0017855120822787285,0.358723908662796,0.0015949844382703304,0.3291811943054199,0.00340676330961287,2.8533923625946045,-0.001418625470250845,-0.08465506136417389,3.0465664863586426,2.6813604831695557,0.0011750237317755818,0.14065313339233398,0.0022723753936588764,0.42491698265075684,0.0015311423921957612,0.31174418330192566,1.2487540245056152,0.0008704880601726472,0.7423526644706726,108.90560150146484,86.52823638916016,99.37796020507812,230.55010986328125,109.8044204711914,-67.15658569335938,135.4252471923828,2067.081787109375,-0.010737263597548008,0.7322945594787598,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,467.2169189453125 +POINT (8258539.548782767 1724515.9709488),,,,3,305.06,343.07,804.0,5.3,38.01,07-05-2017,n,0.48,VIIRS,0,1,2.0,D,N,0.4,Moderate Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.05792616680264473,307.1551208496094,-0.0008305389201268554,0.39923617243766785,-0.0009881769074127078,0.3714723587036133,-0.0008701516198925674,2.8861184120178223,0.0003406304167583585,-0.12789414823055267,3.0465664863586426,2.6813604831695557,-0.00045663610217161477,0.18644283711910248,0.00031854267581366,0.4777415096759796,0.000665009138174355,0.33057400584220886,7.686184883117676,0.001145554124377668,0.7569004893302917,118.54546356201172,88.72157287597656,92.86561584472656,268.12969970703125,93.51020812988281,-9.483024597167969,150.03648376464844,2096.291259765625,-0.008658132515847683,0.7385255694389343,-0.15413472056388855,32.54884338378906,0.040253520011901855,21.723073959350586,564.7798461914062 +POINT (8261747.187739463 1723126.483547355),,,,3,309.53,353.65,804.0,16.68,44.12,23-03-2018,n,0.48,VIIRS,0,1,2.0,D,N,0.4,Moderate Risk,,,,High Risk,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.0387001596391201,306.10150146484375,-0.0006230331491678953,0.33777233958244324,-0.0009077944559976459,0.30841749906539917,0.0015546465292572975,2.794292449951172,0.0011573942610993981,-0.06704041361808777,3.0465664863586426,2.6813604831695557,-0.0010701428400352597,0.11357075721025467,-0.0007731846417300403,0.3862539529800415,-0.0005004101549275219,0.3041277825832367,2.6340579986572266,-0.00044163368875160813,0.7426783442497253,137.00819396972656,73.5905990600586,84.58448028564453,362.0931701660156,83.6349105834961,95.75440979003906,133.45021057128906,1982.5421142578125,-0.009164434857666492,0.7120571732521057,-0.10924012213945389,32.40185546875,0.05537993460893631,21.012279510498047,512.9251708984375 +POINT (8262448.083159899 1724202.5573690943),,,,3,306.73,348.16,809.0,3.27,41.43,30-03-2013,n,0.41,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.127770334482193,308.4954833984375,-0.00022227743465919048,0.37760409712791443,-0.0008088361355476081,0.3475519120693207,0.00570603646337986,2.903172016143799,0.0027283949311822653,-0.09087750315666199,3.0465664863586426,2.6813604831695557,-0.0031754551455378532,0.1397242546081543,-0.002396202413365245,0.42366504669189453,-0.0005731948767788708,0.3229983448982239,10.049494743347168,-0.0014830766012892127,0.7246696949005127,172.75828552246094,-126.00104522705078,117.40398406982422,164.73410034179688,110.79875183105469,-51.90526580810547,158.16043090820312,2005.103271484375,-0.015651756897568703,0.7473052144050598,-0.09277967363595963,31.75627899169922,0.052264127880334854,21.23915672302246,681.3757934570312 +POINT (8260809.516741443 1760619.872588279),,,,3,306.68,347.5,810.0,24.54,40.82,18-05-2019,n,0.41,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,12.756263732910156,1992.9703369140625,0.0439036525785923,17.53630256652832,0.10819530487060547,303.400634765625,-0.002702473197132349,0.43465662002563477,-0.002944227773696184,0.39650121331214905,-0.011824863031506538,2.8692548274993896,-0.002910755341872573,-0.17933516204357147,2.306614875793457,2.9972360134124756,0.002479107351973653,0.2333350032567978,0.0022704394068568945,0.5394780039787292,0.0010594362393021584,0.35270756483078003,10.826446533203125,0.0034197785425931215,0.7965651154518127,87.46121978759766,28.675857543945312,71.85070037841797,223.40101623535156,91.14278411865234,-69.5226821899414,74.67566680908203,2303.396728515625,-0.009403218515217304,0.7962608337402344,-0.031189966946840286,29.349414825439453,0.03881462663412094,21.18943214416504,848.26708984375 +POINT (8259402.2656671265 1725368.7440782795),,,,3,307.55,347.38,810.0,5.25,39.83,15-03-2019,n,0.41,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.054833848029375076,303.31854248046875,0.0007882953505031765,0.3059927523136139,0.0006238637142814696,0.2772218585014343,0.001760927028954029,2.51957631111145,0.0004663171712309122,-0.20357070863246918,3.0465664863586426,2.6813604831695557,-0.0009555470896884799,0.27102628350257874,-0.0006696565542370081,0.5542693734169006,0.00015077866555657238,0.3379771411418915,30.938894271850586,-0.0003793543728534132,0.8794875144958496,103.72914123535156,-18.282379150390625,90.05928039550781,156.77867126464844,103.66964721679688,-112.07996368408203,61.9042854309082,1788.2620849609375,-0.01903495006263256,0.7851295471191406,-0.09384360909461975,31.274198532104492,0.03593318536877632,22.008705139160156,1016.1616821289062 +POINT (8263444.823956099 1724414.5871292723),,,,3,307.23,344.34,811.0,6.27,37.11,22-03-2016,n,0.42,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.08647727221250534,305.72088623046875,-0.001685181981883943,0.4022195637226105,-0.0018689398420974612,0.37141600251197815,0.001966240582987666,2.8257601261138916,0.0035473781172186136,-0.1645078957080841,3.0465664863586426,2.6813604831695557,-0.003795529482886195,0.22096680104732513,-0.0035041572991758585,0.5198404788970947,-0.001053923973813653,0.3502846658229828,4.059841156005859,-0.001263469341211021,0.7945724725723267,136.0124053955078,83.11888122558594,116.79216003417969,246.01023864746094,114.82978057861328,2.5476739406585693,161.05361938476562,2135.800537109375,-0.011322150938212872,0.7515108585357666,-0.08672177046537399,31.27064323425293,0.05537831410765648,21.17612648010254,1653.06591796875 +POINT (8259241.93335778 1724531.9247865498),,,,3,314.58,351.1,816.0,11.13,36.52,05-04-2015,l,0.41,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.16175515949726105,307.8304138183594,-0.0018387265736237168,0.35849156975746155,-0.0021986362989991903,0.3307850956916809,0.0021880443673580885,2.826932430267334,0.003480224870145321,-0.09501747041940689,3.0465664863586426,2.6813604831695557,-0.003581698751077056,0.1455346643924713,-0.0032492897007614374,0.4259924590587616,-0.0011201035231351852,0.3183339536190033,2.4161107540130615,-0.0012056269915774465,0.746135950088501,145.17787170410156,10.366253852844238,113.45658111572266,194.56307983398438,131.5275115966797,-128.87652587890625,150.0732879638672,1968.2020263671875,-0.01478694286197424,0.7377985715866089,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,548.3385620117188 +POINT (8262792.077866955 1724312.1744642786),,,,3,312.42,348.4,816.0,7.44,35.98,05-04-2015,n,0.41,VIIRS,0,1,2.0,D,N,0.37,Moderate Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.15952198207378387,305.2252197265625,-0.00047832680866122246,0.39355146884918213,-0.0007130407611839473,0.36543577909469604,0.005338685587048531,2.79423451423645,0.0034315078519284725,-0.16486525535583496,3.0465664863586426,2.6813604831695557,-0.0039071375504136086,0.22279424965381622,-0.003429663134738803,0.5158371329307556,-0.0006632938166148961,0.3466469347476959,5.308525562286377,-0.001996851060539484,0.7967967391014099,123.15777587890625,79.56909942626953,105.28059387207031,242.38351440429688,105.6937026977539,-12.64005184173584,155.6062469482422,2044.07568359375,-0.008352702483534813,0.735599160194397,-0.08672177046537399,31.27064323425293,0.05537831410765648,21.17612648010254,1020.2109375 +POINT (8259904.110759239 1712217.145811043),,,,3,306.37,353.48,816.0,10.01,47.11,07-05-2019,n,0.39,VIIRS,3,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,18.551830291748047,2328.795654296875,0.07300230115652084,14.763771057128906,-0.011170260608196259,305.1404113769531,-0.0014035082422196865,0.388773649930954,-0.0017161160940304399,0.35939082503318787,-0.0011446651769801974,2.856858253479004,0.0011644067708402872,-0.12658992409706116,3.2029500007629395,2.5971996784210205,-0.001108364900574088,0.1771734654903412,-0.00042219413444399834,0.4652484059333801,-0.0002588187635410577,0.3351559638977051,15.364158630371094,0.0008344775415025651,0.7585928440093994,100.55213928222656,41.313560485839844,83.56103515625,225.8474884033203,108.73534393310547,-92.76527404785156,87.28367614746094,2216.256103515625,-0.010062336921691895,0.7610608339309692,-0.1258036345243454,31.084882736206055,0.03559151664376259,22.250558853149414,1271.2769775390625 +POINT (8260673.5072901705 1736148.60600385),,,,3,305.18,347.3,818.0,2.7,42.12,12-04-2016,n,0.39,VIIRS,0,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,16.12369728088379,2153.84423828125,0.05328503996133804,16.63265609741211,0.10755137354135513,304.57806396484375,0.000247041170950979,0.43651866912841797,0.000302847329294309,0.40569156408309937,0.004271842539310455,2.902700424194336,0.0018059613648802042,-0.17901897430419922,3.2316770553588867,2.59718656539917,-0.001712979283183813,0.2313796579837799,-0.0016289117047563195,0.5503764152526855,-0.0005316175520420074,0.37198469042778015,7.1589202880859375,-0.0015821249689906836,0.8031694293022156,123.56472778320312,-0.5606128573417664,105.23426818847656,181.20155334472656,110.03533172607422,-98.82671356201172,146.39097595214844,2332.05859375,-0.011330016888678074,0.7939006686210632,-0.10881152004003525,32.23927688598633,0.02964937686920166,21.448375701904297,598.531494140625 +POINT (8257791.0004159 1693974.3207682706),,,,3,305.06,340.12,822.0,4.83,35.06,06-03-2018,n,0.39,VIIRS,0,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,0.06684163957834244,307.09295654296875,-0.0021771288011223078,0.30556875467300415,-0.0033319236245006323,0.2944968044757843,-0.014572408981621265,3.1010818481445312,0.003630832303315401,0.06297358125448227,2.8360955715179443,2.6934564113616943,-0.005947311874479055,0.0033800764940679073,-0.009142554365098476,0.23694610595703125,-0.0037965811789035797,0.24274519085884094,24.537710189819336,-0.0033794869668781757,0.5372471213340759,177.967041015625,136.2792510986328,147.9857177734375,204.0939178466797,150.11312866210938,-101.20134735107422,103.73414611816406,2601.957275390625,-0.02144770137965679,0.6840411424636841,-0.12909908592700958,30.380321502685547,0.031377870589494705,21.596834182739258,2808.04833984375 +POINT (8259661.378563352 1722707.0798926777),,,,3,312.08,352.1,822.0,5.08,40.02,22-03-2018,n,0.39,VIIRS,0,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,19.745206832885742,2261.209228515625,0.06798024475574493,15.237241744995117,0.03937860205769539,309.0347595214844,-0.0006008715135976672,0.351847767829895,-0.0007441785419359803,0.31948310136795044,0.0032612427603453398,2.790069341659546,0.0021107960492372513,-0.09472686797380447,3.0465664863586426,2.6813604831695557,-0.002112670335918665,0.14505843818187714,-0.001857569208368659,0.4265260398387909,-0.0005831154994666576,0.3144836127758026,6.003132343292236,-0.0013313263189047575,0.7643564343452454,65.12767791748047,203.16165161132812,56.71596908569336,337.5433044433594,69.96644592285156,61.773406982421875,103.36272430419922,2078.04248046875,-0.0056586358696222305,0.7167935371398926,-0.13133341073989868,32.796775817871094,0.051451992243528366,21.14882469177246,741.0244140625 +POINT (8261658.83123462 1723147.0679630714),,,,3,305.9,343.51,824.0,4.95,37.61,17-04-2016,n,0.39,VIIRS,0,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,18.488798141479492,2254.447021484375,0.06798024475574493,15.237241744995117,0.043329887092113495,306.463623046875,-0.0006089071976020932,0.34088072180747986,-0.0007361297612078488,0.3089853525161743,0.003489023307338357,2.7096285820007324,0.002223891206085682,-0.12459096312522888,3.0465664863586426,2.6813604831695557,-0.0021424235310405493,0.17826105654239655,-0.0017062508268281817,0.46177080273628235,-0.0004611601762007922,0.3226354420185089,10.142414093017578,-0.0012355479411780834,0.7996919751167297,101.83281707763672,86.90328979492188,53.86380386352539,377.1639709472656,66.88020324707031,103.46971893310547,118.23860931396484,1884.1038818359375,-0.006135599687695503,0.7193648219108582,-0.10924012213945389,32.40185546875,0.05537993460893631,21.012279510498047,495.0260925292969 +POINT (8265548.006602263 1724921.5104813292),,,,3,306.82,351.53,824.0,12.53,44.71,17-04-2016,n,0.39,VIIRS,0,1,2.0,D,N,0.36,Moderate Risk,,,,High Risk,18.239013671875,2170.728271484375,0.06290382146835327,15.734601974487305,0.12029510736465454,303.7958984375,-0.002568845869973302,0.3560614585876465,-0.00269227079115808,0.32440513372421265,-0.0021935750264674425,2.741217613220215,0.00255790282972157,-0.130532369017601,4.112709045410156,2.169313669204712,-0.0025252525229007006,0.18138806521892548,-0.0020638499408960342,0.4670366644859314,-0.0007454912993125618,0.32831674814224243,11.330280303955078,0.00047820675536058843,0.7930876016616821,110.92981719970703,38.08283996582031,95.05976104736328,200.45826721191406,106.47457885742188,-47.260704040527344,122.2177734375,1826.119140625,-0.012320407666265965,0.7548701763153076,-0.0759788528084755,30.753421783447266,0.04798030108213425,21.359045028686523,2278.204345703125 +POINT (8259736.829061868 1724725.4302380497),,,,3,305.47,344.98,829.0,3.9,39.51,25-04-2017,n,0.44,VIIRS,0,1,2.0,D,N,0.38,Moderate Risk,,,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.16176170110702515,307.7324523925781,-0.0006050251540727913,0.34639212489128113,-0.0009059908334165812,0.3194117248058319,-0.002578916260972619,2.9777512550354004,0.0014604933094233274,-0.014392639510333538,3.0465664863586426,2.6813604831695557,-0.0017964572180062532,0.06376056373119354,-0.0028071298729628325,0.33474022150039673,-0.0015445156022906303,0.28870752453804016,5.705350875854492,-0.0013294877717271447,0.6591832637786865,109.04148864746094,158.64561462402344,96.4761962890625,275.09130859375,99.33989715576172,0.6827641129493713,132.5497589111328,2100.493408203125,-0.011939688585698605,0.7012676000595093,-0.13611160218715668,32.90052795410156,0.05264192819595337,21.62228012084961,303.40106201171875 +POINT (8262068.845127877 1725985.3121451652),,,,3,305.96,341.81,835.0,3.95,35.85,04-04-2015,n,0.44,VIIRS,0,1,2.0,D,N,0.38,Moderate Risk,,,,High Risk,17.406888961791992,2192.45166015625,0.06798024475574493,15.237241744995117,0.08084475994110107,303.6361999511719,-0.0010220353724434972,0.4055553376674652,-0.001274602604098618,0.3774353861808777,-0.0008995758253149688,2.77370548248291,0.0009491928503848612,-0.19721314311027527,3.0465664863586426,2.6813604831695557,-0.0011015862692147493,0.25362321734428406,-0.000991912093013525,0.5594647526741028,-0.00046090412070043385,0.3637048900127411,12.972772598266602,-0.00016612856416031718,0.8273943066596985,173.23838806152344,-2.7652854919433594,117.901123046875,248.27618408203125,102.889404296875,37.20430374145508,180.56312561035156,2034.7750244140625,-0.014623562805354595,0.7685454487800598,-0.09755739569664001,31.091567993164062,0.03973795846104622,21.434123992919922,1455.483154296875 +POINT (8258594.873259354 1724291.304348505),,,,3,303.73,339.31,804.0,6.67,36.0,03-04-2022,n,0.48,VIIRS,0,2,,D,N,0.4,,15.30427,74.18822,,High Risk,18.47934341430664,2241.210693359375,0.06798024475574493,15.237241744995117,0.06133941560983658,308.17120361328125,-0.0032227830961346626,0.3354068100452423,-0.0033504662569612265,0.30798712372779846,-0.006298344116657972,2.9036734104156494,0.003377234796062112,-0.030921747907996178,3.0465664863586426,2.6813604831695557,-0.0034994829911738634,0.08004901558160782,-0.004845676012337208,0.3575007915496826,-0.0023354908917099237,0.29868611693382263,2.0032565593719482,-0.0005534185329452157,0.7001092433929443,131.72874450683594,99.94438934326172,93.67636108398438,283.87884521484375,92.86212158203125,11.390274047851562,134.3272247314453,1925.8934326171875,-0.012976771220564842,0.7009264826774597,-0.15413472056388855,32.54884338378906,0.040253520011901855,21.723073959350586,374.96588134765625 +POINT (8270843.356831337 1711624.6580393764),,,,3,292.98,332.09,2055.0,5.36,39.0,28-01-2022,n,0.54,VIIRS,0,2,,N,N,0.42,,15.19449,74.29825,,High Risk,17.89788818359375,2369.10595703125,0.05740818381309509,16.241392135620117,0.03672073408961296,302.1248474121094,-0.0011264999629929662,0.4042935073375702,-0.0012308943551033735,0.37371692061424255,-0.003164195455610752,2.709014654159546,0.00022047852689865977,-0.19981461763381958,5.316018104553223,1.480040192604065,-0.00022042475757189095,0.2621685862541199,-0.0007491459837183356,0.5389301180839539,-0.00082622334593907,0.3270781338214874,10.999146461486816,0.00012400042032822967,0.8161163330078125,119.37775421142578,-46.1629524230957,95.22669982910156,134.25672912597656,108.48634338378906,-150.4351043701172,80.70905303955078,1998.132080078125,-0.011447099968791008,0.7802364230155945,-0.051267534494400024,27.999706268310547,0.02773132734000683,19.967836380004883,3466.9921875 +POINT (8260799.092685434 1747818.8188920969),,,,3,300.35,338.36,835.0,5.77,38.0,24-05-2020,n,0.53,VIIRS,False,True,,D,N,0.42,,15.50802663,74.20802084,0021000000000001f1e1,High Risk,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.4278840720653534,303.9676513671875,-0.005038201343268156,0.4403245747089386,-0.00546948192641139,0.40723124146461487,0.0017108514439314604,2.8001463413238525,0.00897287204861641,-0.23078182339668274,2.976552724838257,2.7044215202331543,-0.009240788407623768,0.28833648562431335,-0.01028275117278099,0.5924839377403259,-0.004230681341141462,0.3723005950450897,8.809950828552246,-0.004547867923974991,0.8287153244018555,91.45005798339844,30.28943634033203,76.4918212890625,207.85281372070312,96.79633331298828,-107.37162017822266,81.11011505126953,2286.55859375,-0.01113317534327507,0.785621702671051,-0.008234169334173203,29.785226821899414,0.0157071053981781,21.783435821533203,1057.646240234375 +POINT (8257190.870653259 1694020.0667141124),,,,3,306.78,348.76,841.0,5.03,42.0,27-04-2020,n,0.43,VIIRS,False,True,,D,N,0.46,,15.0418187,74.17560763,0021000000000001a1ce,High Risk,24.17653465270996,2497.590087890625,0.07669062167406082,14.396920204162598,-0.026013771072030067,304.5926208496094,0.002090438501909375,0.4128010869026184,0.0019531308207660913,0.38409706950187683,0.00422387570142746,2.7889044284820557,-0.001481237355619669,-0.17995868623256683,2.8360955715179443,2.6934564113616943,0.0011073009809479117,0.24178627133369446,0.0024812952615320683,0.5194050073623657,0.0019952983129769564,0.32781171798706055,8.39522647857666,0.0008060740074142814,0.7850118279457092,176.9959259033203,63.363067626953125,154.00955200195312,183.63674926757812,146.86312866210938,-37.07499694824219,172.31280517578125,2198.795654296875,-0.013573475182056427,0.7357918620109558,-0.09457297623157501,29.16918182373047,0.037218090146780014,21.435815811157227,2425.06640625 +POINT (8260877.521719477 1747957.9072873318),,,,3,303.72,338.27,812.0,2.62,35.0,10-04-2021,n,0.39,VIIRS,False,True,,D,N,0.36,,15.50923059,74.20872538,0021000000000004940c,High Risk,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.696722686290741,302.9057922363281,-0.022537847980856895,0.5474085807800293,-0.025005416944622993,0.5276451706886292,0.022143349051475525,2.7673168182373047,0.04760153964161873,-0.39970862865448,2.976552724838257,2.7044215202331543,-0.051239583641290665,0.46559181809425354,-0.06085968017578125,0.7922679781913757,-0.02357683703303337,0.45374253392219543,10.764947891235352,-0.04064834490418434,0.9412028789520264,90.85977172851562,138.8501434326172,81.24369049072266,230.29457092285156,94.29408264160156,-36.511512756347656,180.79530334472656,1776.4483642578125,-0.0024675314780324697,0.6853726506233215,-0.033479318022727966,30.86818504333496,0.029515668749809265,21.253829956054688,982.650146484375 +POINT (8263173.301426734 1693285.0626771546),,,,3,303.69,341.92,818.0,8.58,38.0,15-04-2021,n,0.39,VIIRS,False,True,,D,N,0.36,,15.03544218,74.22934872,0021000000000004b094,High Risk,23.021440505981445,2472.308349609375,0.07669062167406082,14.396920204162598,-0.033369679003953934,306.5061950683594,0.0015379661926999688,0.31140759587287903,0.0004958338104188442,0.29359984397888184,0.0030307432170957327,2.9593091011047363,-0.0014063676353543997,0.044853098690509796,2.8360955715179443,2.6934564113616943,-0.00022579926007892936,0.01854642666876316,0.002213828032836318,0.24750083684921265,0.002282196655869484,0.23796004056930542,9.648127555847168,0.004689189605414867,0.5708510279655457,154.40879821777344,145.38571166992188,123.98078918457031,247.69798278808594,127.75004577636719,-60.09476852416992,89.6086654663086,2515.30908203125,-0.029086347669363022,0.7492318153381348,-0.08162467181682587,28.571617126464844,0.037905946373939514,20.65917205810547,1883.9742431640625 +POINT (8263224.925840588 1747924.9384723173),,,,3,306.31,343.89,818.0,24.1,38.0,14-03-2021,n,0.4,VIIRS,False,True,,D,N,0.37,,15.50894521,74.22981247,2.10E+18,High Risk,14.928257942199707,2073.187744140625,0.04621821641921997,17.30975914001465,0.13693293929100037,303.36480712890625,-0.00038638358819298446,0.5670881271362305,-0.00028922263300046325,0.5378729701042175,-0.0010197119554504752,2.93266224861145,0.0001318770373472944,-0.3094739317893982,2.976552724838257,2.7044215202331543,0.00018702403758652508,0.3630066514015198,-0.00019913772121071815,0.6689431071281433,-0.0005303230136632919,0.4049989879131317,16.590944290161133,-0.00015321587852668017,0.8304415345191956,144.1822509765625,-130.5375518798828,130.44337463378906,65.53976440429688,134.32403564453125,-210.98245239257812,119.50326538085938,2637.23291015625,-0.017921194434165955,0.8625810742378235,-0.023874539881944656,29.48159408569336,0.04022873938083649,21.570602416992188,1060.432373046875 diff --git a/img/fire_events_by_month.png b/img/fire_events_by_month.png new file mode 100644 index 0000000..7b99829 Binary files /dev/null and b/img/fire_events_by_month.png differ diff --git a/img/fire_events_by_year.png b/img/fire_events_by_year.png new file mode 100644 index 0000000..fbff03c Binary files /dev/null and b/img/fire_events_by_year.png differ diff --git a/notebooks/data_exploration.ipynb b/notebooks/data_exploration.ipynb new file mode 100644 index 0000000..8b6a29d --- /dev/null +++ b/notebooks/data_exploration.ipynb @@ -0,0 +1,715 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# # Forest Fire Data Exploration for Goa\n", + "# \n", + "# This script explores the datasets used in the forest fire vulnerability and \n", + "# prediction project for Goa, India. It is structured in sections that can be \n", + "# easily converted to notebook cells later." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Libraries imported successfully!\n" + ] + } + ], + "source": [ + "# CELL 1: Import necessary libraries\n", + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from datetime import datetime\n", + "import geopandas as gpd\n", + "import folium\n", + "from folium.plugins import HeatMap\n", + "import rasterio\n", + "from rasterio.plot import show\n", + "\n", + "# Set up plotting style\n", + "plt.style.use('seaborn-v0_8-whitegrid')\n", + "sns.set_context(\"talk\")\n", + "\n", + "print(\"Libraries imported successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checking contents of data directory...\n", + "\n", + "Shapefiles (base names):\n", + "- fire13_19\n", + "- pa_boundary\n", + "- fire20_23\n", + "\n", + "Raster files:\n", + "- road.tif\n", + "- inputResampled.tif\n", + "- dem.tif\n", + "\n", + "Other files:\n", + "- pa_boundary.qmd\n", + "- fire13_19.fix\n" + ] + } + ], + "source": [ + "# CELL 2: Data Inventory - List all files in the data directory\n", + "\n", + "data_dir = '../data'\n", + "print(f\"Checking contents of {data_dir} directory...\")\n", + "\n", + "if not os.path.exists(data_dir):\n", + " print(f\"Warning: {data_dir} directory not found!\")\n", + "else:\n", + " all_files = os.listdir(data_dir)\n", + " \n", + " # Group files by type\n", + " shapefile_extensions = ['.shp', '.shx', '.dbf', '.prj', '.cpg']\n", + " raster_extensions = ['.tif', '.tiff']\n", + " \n", + " # Organize files by category\n", + " shapefiles = [f for f in all_files if any(f.endswith(ext) for ext in shapefile_extensions)]\n", + " raster_files = [f for f in all_files if any(f.endswith(ext) for ext in raster_extensions)]\n", + " other_files = [f for f in all_files if f not in shapefiles and f not in raster_files]\n", + " \n", + " # Extract unique shapefile base names (without extensions)\n", + " shapefile_bases = set()\n", + " for file in shapefiles:\n", + " for ext in shapefile_extensions:\n", + " if file.endswith(ext):\n", + " shapefile_bases.add(file.replace(ext, ''))\n", + " \n", + " print(\"\\nShapefiles (base names):\")\n", + " for base in shapefile_bases:\n", + " print(f\"- {base}\")\n", + " \n", + " print(\"\\nRaster files:\")\n", + " for file in raster_files:\n", + " print(f\"- {file}\")\n", + " \n", + " print(\"\\nOther files:\")\n", + " for file in other_files:\n", + " print(f\"- {file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total fire events: 267\n", + "Fire events from 2013-2019: 197\n", + "Fire events from 2020-2023: 70\n", + "\n", + "Columns in the fire dataset:\n", + "['bright_ti5', 'bright_ti4', 'acq_time', 'frp', 'Delta T', 'acq_date', 'confidence', 'scan', 'instrument', 'type', 'version', 'RiskNumeri', 'daynight', 'satellite', 'track', 'RiskCatego', 'geometry', 'latitude', 'longitude', 'system_ind']\n", + "\n", + "Sample of fire data:\n", + " bright_ti5 bright_ti4 acq_time frp Delta T acq_date confidence scan instrument type version RiskNumeri daynight satellite track RiskCatego geometry latitude longitude system_ind\n", + "0 297.82 334.69 726 4.47 36.87 26-04-2018 n 0.62 VIIRS 0 1 3.0 D N 0.72 High Risk POINT (74.19322 15.6126) NaN NaN NaN\n", + "1 300.19 335.37 738 2.30 35.18 06-04-2013 n 0.38 VIIRS 0 1 3.0 D N 0.59 High Risk POINT (74.19879 15.30833) NaN NaN NaN\n", + "2 307.68 335.97 750 4.72 28.29 29-03-2014 n 0.61 VIIRS 0 1 3.0 D N 0.53 High Risk POINT (74.24989 15.31958) NaN NaN NaN\n", + "3 309.35 367.00 751 17.63 57.65 16-04-2013 h 0.47 VIIRS 0 1 3.0 D N 0.48 High Risk POINT (74.15782 15.59127) NaN NaN NaN\n", + "4 301.31 350.13 751 10.45 48.82 16-04-2013 n 0.48 VIIRS 0 1 3.0 D N 0.48 High Risk POINT (74.17966 15.04022) NaN NaN NaN\n", + "\n", + "Fire events by year:\n", + " 2013: 19 events\n", + " 2014: 3 events\n", + " 2015: 21 events\n", + " 2016: 58 events\n", + " 2017: 25 events\n", + " 2018: 42 events\n", + " 2019: 29 events\n", + " 2020: 9 events\n", + " 2021: 6 events\n", + " 2022: 4 events\n", + " 2023: 51 events\n", + "\n", + "Fire events by month (all years combined):\n", + " Jan: 11 events\n", + " Feb: 9 events\n", + " Mar: 93 events\n", + " Apr: 120 events\n", + " May: 29 events\n", + " Dec: 5 events\n", + "Saved plot: fire_events_by_year.png\n", + "Saved plot: fire_events_by_month.png\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/03/70byyv1n5g7d83j8pp_3_phc0000gn/T/ipykernel_70420/4137265159.py:30: UserWarning: Parsing dates in %d-%m-%Y format when dayfirst=False (the default) was specified. Pass `dayfirst=True` or specify a format to silence this warning.\n", + " fire_all['acq_date'] = pd.to_datetime(fire_all['acq_date'])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# CELL 3: Fire Events Data Analysis\n", + "\n", + "try:\n", + " # Load the fire events data\n", + " fire13_19_path = os.path.join(data_dir, 'fire13_19.shp')\n", + " fire20_23_path = os.path.join(data_dir, 'fire20_23.shp')\n", + " \n", + " if os.path.exists(fire13_19_path) and os.path.exists(fire20_23_path):\n", + " fire13_19 = gpd.read_file(fire13_19_path)\n", + " fire20_23 = gpd.read_file(fire20_23_path)\n", + " \n", + " # Combine datasets\n", + " fire_all = pd.concat([fire13_19, fire20_23], ignore_index=True)\n", + " \n", + " print(f\"Total fire events: {len(fire_all)}\")\n", + " print(f\"Fire events from 2013-2019: {len(fire13_19)}\")\n", + " print(f\"Fire events from 2020-2023: {len(fire20_23)}\")\n", + " \n", + " # Preview the data\n", + " print(\"\\nColumns in the fire dataset:\")\n", + " print(fire_all.columns.tolist())\n", + " \n", + " print(\"\\nSample of fire data:\")\n", + " print(fire_all.head().to_string())\n", + " \n", + " # Analyze temporal distribution if date field exists\n", + " if 'acq_date' in fire_all.columns:\n", + " # Convert to datetime if it's not already\n", + " if not pd.api.types.is_datetime64_any_dtype(fire_all['acq_date']):\n", + " fire_all['acq_date'] = pd.to_datetime(fire_all['acq_date'])\n", + " \n", + " # Extract year and month\n", + " fire_all['year'] = fire_all['acq_date'].dt.year\n", + " fire_all['month'] = fire_all['acq_date'].dt.month\n", + " \n", + " # Yearly distribution\n", + " yearly_counts = fire_all.groupby('year').size()\n", + " \n", + " print(\"\\nFire events by year:\")\n", + " for year, count in yearly_counts.items():\n", + " print(f\" {year}: {count} events\")\n", + " \n", + " # Monthly distribution\n", + " monthly_counts = fire_all.groupby('month').size()\n", + " month_names = {\n", + " 1: 'Jan', 2: 'Feb', 3: 'Mar', 4: 'Apr', 5: 'May', 6: 'Jun',\n", + " 7: 'Jul', 8: 'Aug', 9: 'Sep', 10: 'Oct', 11: 'Nov', 12: 'Dec'\n", + " }\n", + " \n", + " print(\"\\nFire events by month (all years combined):\")\n", + " for month, count in monthly_counts.items():\n", + " print(f\" {month_names[month]}: {count} events\")\n", + " \n", + " # Create and save yearly plot\n", + " plt.figure(figsize=(12, 6))\n", + " yearly_counts.plot(kind='bar', color='firebrick')\n", + " plt.title('Number of Fire Events by Year')\n", + " plt.xlabel('Year')\n", + " plt.ylabel('Number of Fire Events')\n", + " plt.xticks(rotation=45)\n", + " plt.tight_layout()\n", + " plt.savefig('img/fire_events_by_year.png')\n", + " print(\"Saved plot: fire_events_by_year.png\")\n", + " \n", + " # Create and save monthly plot\n", + " plt.figure(figsize=(12, 6))\n", + " monthly_counts_labeled = pd.Series([monthly_counts.get(i, 0) for i in range(1, 13)], \n", + " index=[month_names[i] for i in range(1, 13)])\n", + " monthly_counts_labeled.plot(kind='bar', color='darkorange')\n", + " plt.title('Number of Fire Events by Month (All Years)')\n", + " plt.xlabel('Month')\n", + " plt.ylabel('Number of Fire Events')\n", + " plt.tight_layout()\n", + " plt.savefig('img/fire_events_by_month.png')\n", + " print(\"Saved plot: fire_events_by_month.png\")\n", + " \n", + " else:\n", + " print(\"Fire event shapefiles not found.\")\n", + "except Exception as e:\n", + " print(f\"Error analyzing fire data: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Study area boundary loaded successfully.\n", + "Boundary CRS: EPSG:4326\n", + "Boundary geometry type: Polygon\n", + "Study area size: 821.24 square kilometers\n", + "Saved plot: study_area_boundary.png\n", + "Saved plot: study_area_with_fires.png\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/03/70byyv1n5g7d83j8pp_3_phc0000gn/T/ipykernel_70420/77088353.py:44: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", + " cmap = plt.cm.get_cmap('viridis', len(years))\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# CELL 4: Study Area Boundary Analysis\n", + "\n", + "try:\n", + " # Load the boundary data\n", + " boundary_path = os.path.join(data_dir, 'pa_boundary.shp')\n", + " \n", + " if os.path.exists(boundary_path):\n", + " boundary = gpd.read_file(boundary_path)\n", + " print(f\"Study area boundary loaded successfully.\")\n", + " print(f\"Boundary CRS: {boundary.crs}\")\n", + " print(f\"Boundary geometry type: {boundary.geometry.geom_type.iloc[0]}\")\n", + " \n", + " # Calculate area \n", + " if boundary.crs and boundary.crs.is_geographic:\n", + " # If geographic coordinates (lat/lon), reproject to a projected CRS for area calculation\n", + " boundary_projected = boundary.to_crs(epsg=3857) # Web Mercator projection\n", + " area_km2 = boundary_projected.area.sum() / 1e6 # Convert from square meters to square km\n", + " print(f\"Study area size: {area_km2:.2f} square kilometers\")\n", + " else:\n", + " # If already in a projected CRS\n", + " area_units = boundary.area.sum()\n", + " print(f\"Study area size: {area_units:.2f} square units (CRS units)\")\n", + " \n", + " # Plot boundary\n", + " plt.figure(figsize=(10, 10))\n", + " boundary.plot(color='lightgray', edgecolor='black')\n", + " plt.title('Study Area Boundary')\n", + " plt.axis('off')\n", + " plt.savefig('img/study_area_boundary.png')\n", + " print(\"Saved plot: study_area_boundary.png\")\n", + " \n", + " # Plot with fire points if available\n", + " if 'fire_all' in locals():\n", + " # Ensure same CRS\n", + " if fire_all.crs != boundary.crs:\n", + " fire_all = fire_all.to_crs(boundary.crs)\n", + " \n", + " plt.figure(figsize=(12, 10))\n", + " boundary.plot(ax=plt.gca(), color='lightgray', edgecolor='black')\n", + " \n", + " # Plot fire events, colored by year if available\n", + " if 'year' in fire_all.columns:\n", + " years = sorted(fire_all['year'].unique())\n", + " cmap = plt.cm.get_cmap('viridis', len(years))\n", + " \n", + " for i, year in enumerate(years):\n", + " year_data = fire_all[fire_all['year'] == year]\n", + " plt.scatter(\n", + " year_data.geometry.x,\n", + " year_data.geometry.y,\n", + " c=[cmap(i)],\n", + " label=f'{year} ({len(year_data)} events)',\n", + " alpha=0.7,\n", + " s=30\n", + " )\n", + " plt.legend(title=\"Fire Events by Year\")\n", + " else:\n", + " plt.scatter(\n", + " fire_all.geometry.x,\n", + " fire_all.geometry.y,\n", + " c='red',\n", + " label='Fire Events',\n", + " alpha=0.7,\n", + " s=30\n", + " )\n", + " plt.legend()\n", + " \n", + " plt.title('Study Area with Fire Events')\n", + " plt.axis('off')\n", + " plt.savefig('img/study_area_with_fires.png')\n", + " print(\"Saved plot: study_area_with_fires.png\")\n", + " \n", + " else:\n", + " print(\"Study area boundary shapefile not found.\")\n", + "except Exception as e:\n", + " print(f\"Error analyzing boundary data: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trend layer loaded successfully.\n", + "Driver: GTiff\n", + "Width: 944, Height: 2912\n", + "Bounds: BoundingBox(left=8246820.0, bottom=1767960.0, right=8275140.0, top=1680600.0)\n", + "CRS: EPSG:3857\n", + "Number of bands: 40\n", + "Data types: ('float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32', 'float32')\n", + "\n", + "Band 1 statistics:\n", + "Min: nan, Max: nan, Mean: nan, Std: nan\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error analyzing trend layer: No mappable was found to use for colorbar creation. First define a mappable such as an image (with imshow) or a contour set (with contourf).\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# CELL 5: Trend Layers Analysis\n", + "\n", + "try:\n", + " # Try to load the trend layer TIF file\n", + " trend_file = \"inputResampled.tif\" \n", + " trend_path = os.path.join(data_dir, trend_file)\n", + " \n", + " if os.path.exists(trend_path):\n", + " # Open the raster file\n", + " with rasterio.open(trend_path) as src:\n", + " # Print metadata\n", + " print(f\"Trend layer loaded successfully.\")\n", + " print(f\"Driver: {src.driver}\")\n", + " print(f\"Width: {src.width}, Height: {src.height}\")\n", + " print(f\"Bounds: {src.bounds}\")\n", + " print(f\"CRS: {src.crs}\")\n", + " print(f\"Number of bands: {src.count}\")\n", + " print(f\"Data types: {src.dtypes}\")\n", + " \n", + " # Read and analyze the first band\n", + " band_to_show = 1 # Start with the first band\n", + " band_data = src.read(band_to_show)\n", + " \n", + " # Get statistics for the band\n", + " band_min = band_data.min()\n", + " band_max = band_data.max()\n", + " band_mean = band_data.mean()\n", + " band_std = band_data.std()\n", + " \n", + " print(f\"\\nBand {band_to_show} statistics:\")\n", + " print(f\"Min: {band_min}, Max: {band_max}, Mean: {band_mean:.2f}, Std: {band_std:.2f}\")\n", + " \n", + " # Plot the band\n", + " plt.figure(figsize=(10, 8))\n", + " show(band_data, transform=src.transform, cmap='viridis', title=f\"Band {band_to_show}\")\n", + " plt.colorbar(label=f\"Band {band_to_show} Value\")\n", + " plt.savefig(f'img/trend_layer_band_{band_to_show}.png')\n", + " print(f\"Saved plot: trend_layer_band_{band_to_show}.png\")\n", + " \n", + " # If there are multiple bands, show a few more\n", + " if src.count > 1:\n", + " for band_idx in range(2, min(4, src.count + 1)):\n", + " band = src.read(band_idx)\n", + " plt.figure(figsize=(10, 8))\n", + " show(band, transform=src.transform, cmap='viridis', title=f\"Band {band_idx}\")\n", + " plt.colorbar(label=f\"Band {band_idx} Value\")\n", + " plt.savefig(f'img/trend_layer_band_{band_idx}.png')\n", + " print(f\"Saved plot: trend_layer_band_{band_idx}.png\")\n", + " else:\n", + " print(f\"The trend layer file '{trend_file}' was not found.\")\n", + " print(\"According to the README, it can be downloaded from:\")\n", + " print(\"https://www.dropbox.com/scl/fi/ena1qfeqv5ppshluop8kt/inputResampled.tif?rlkey=arefwl3my7nx3z5qpknu88lsx&st=vj8cn3bd&dl=0\")\n", + "except Exception as e:\n", + " print(f\"Error analyzing trend layer: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model Training and Testing Dataset Evaluation:\n", + "Total fire events: 267\n", + "Training events (2013-2020): 206\n", + "Testing events (2021-2023): 61\n", + "\n", + "Training data sufficient: Yes\n", + "Testing data sufficient: Yes\n", + "\n", + "No temporal gaps in the data.\n" + ] + } + ], + "source": [ + "# CELL 6: Model Training and Testing Dataset Evaluation\n", + "\n", + "try:\n", + " if 'fire_all' in locals() and len(fire_all) > 0:\n", + " # Count total events\n", + " total_events = len(fire_all)\n", + " print(f\"\\nModel Training and Testing Dataset Evaluation:\")\n", + " print(f\"Total fire events: {total_events}\")\n", + " \n", + " # Define training period (e.g., 2013-2020) and testing period (e.g., 2021-2023)\n", + " if 'year' in fire_all.columns:\n", + " train_years = range(2013, 2021) # Adjust as needed\n", + " test_years = range(2021, 2024) # Adjust as needed\n", + " \n", + " train_events = fire_all[fire_all['year'].isin(train_years)]\n", + " test_events = fire_all[fire_all['year'].isin(test_years)]\n", + " \n", + " print(f\"Training events (2013-2020): {len(train_events)}\")\n", + " print(f\"Testing events (2021-2023): {len(test_events)}\")\n", + " \n", + " # Check if we have enough events for both periods\n", + " train_sufficient = len(train_events) >= 100 # Arbitrary threshold\n", + " test_sufficient = len(test_events) >= 30 # Arbitrary threshold\n", + " \n", + " print(f\"\\nTraining data sufficient: {'Yes' if train_sufficient else 'No'}\")\n", + " print(f\"Testing data sufficient: {'Yes' if test_sufficient else 'No'}\")\n", + " \n", + " # Check for temporal gaps\n", + " year_counts = fire_all.groupby('year').size()\n", + " all_years = set(range(min(fire_all['year']), max(fire_all['year']) + 1))\n", + " missing_years = all_years - set(year_counts.index)\n", + " \n", + " if missing_years:\n", + " print(f\"\\nWarning: Missing data for years: {missing_years}\")\n", + " else:\n", + " print(\"\\nNo temporal gaps in the data.\")\n", + " else:\n", + " print(\"Year information not available to assess temporal distribution.\")\n", + " else:\n", + " print(\"Fire event data not available for model evaluation.\")\n", + "except Exception as e:\n", + " print(f\"Error evaluating model data requirements: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================================================\n", + "SUMMARY OF FINDINGS AND RECOMMENDATIONS\n", + "==================================================\n", + "\n", + "FINDINGS:\n", + "- Found 267 fire events.\n", + "- Fire events cover 11 years from 2013 to 2023.\n", + "- Study area boundary data is available.\n", + "- The trend layer file (inputResampled.tif) is available locally.\n", + "- The road layer file (road.tif) is available.\n", + "- The dataset appears to have sufficient fire events for both training and testing.\n", + "\n", + "RECOMMENDATIONS:\n", + "- All necessary data appears to be available and sufficient for the analysis.\n", + "\n", + "Next Steps:\n", + "1. Ensure all required datasets are downloaded and properly formatted\n", + "2. Prepare training and testing datasets based on appropriate temporal splits\n", + "3. Apply the methodology described in the README for fire vulnerability mapping\n", + "4. Evaluate model performance using metrics like precision, recall, and F1-score\n", + "5. Generate predictions for future fire-prone areas\n", + "\n", + "This script generated several visualization files. Check your directory for the PNG files.\n" + ] + } + ], + "source": [ + "# CELL 7: Summary of Findings and Recommendations\n", + "\n", + "print(\"\\n\" + \"=\"*50)\n", + "print(\"SUMMARY OF FINDINGS AND RECOMMENDATIONS\")\n", + "print(\"=\"*50)\n", + "\n", + "findings = []\n", + "recommendations = []\n", + "\n", + "# Check if we have the key datasets\n", + "if 'fire_all' in locals() and len(fire_all) > 0:\n", + " findings.append(f\"- Found {len(fire_all)} fire events.\")\n", + " if 'year' in fire_all.columns:\n", + " years = sorted(fire_all['year'].unique())\n", + " findings.append(f\"- Fire events cover {len(years)} years from {min(years)} to {max(years)}.\")\n", + "else:\n", + " findings.append(\"- Fire event data is missing or could not be loaded.\")\n", + " recommendations.append(\"- Acquire or fix the fire event datasets (fire13_19.shp and fire20_23.shp).\")\n", + "\n", + "if 'boundary' in locals():\n", + " findings.append(\"- Study area boundary data is available.\")\n", + "else:\n", + " findings.append(\"- Study area boundary data is missing or could not be loaded.\")\n", + " recommendations.append(\"- Ensure the pa_boundary.shp file is available and properly formatted.\")\n", + "\n", + "# Check for the trend layer file\n", + "if os.path.exists(os.path.join(data_dir, \"inputResampled.tif\")):\n", + " findings.append(\"- The trend layer file (inputResampled.tif) is available locally.\")\n", + "else:\n", + " findings.append(\"- The trend layer file (inputResampled.tif) is not available locally.\")\n", + " recommendations.append(\"- Download the trend layer file from the Dropbox link provided in the README.\")\n", + "\n", + "# Check for the road data\n", + "if os.path.exists(os.path.join(data_dir, \"road.tif\")):\n", + " findings.append(\"- The road layer file (road.tif) is available.\")\n", + "else:\n", + " findings.append(\"- The road layer file (road.tif) is not available or could not be loaded.\")\n", + " recommendations.append(\"- Ensure the road.tif file is available for fire vulnerability mapping.\")\n", + "\n", + "# Model training/testing dataset assessment\n", + "if 'train_sufficient' in locals() and 'test_sufficient' in locals():\n", + " if train_sufficient and test_sufficient:\n", + " findings.append(\"- The dataset appears to have sufficient fire events for both training and testing.\")\n", + " else:\n", + " if not train_sufficient:\n", + " findings.append(\"- The training dataset may not have enough fire events.\")\n", + " recommendations.append(\"- Consider acquiring more historical fire data for training.\")\n", + " if not test_sufficient:\n", + " findings.append(\"- The testing dataset may not have enough fire events.\")\n", + " recommendations.append(\"- Consider using cross-validation techniques to maximize use of available data.\")\n", + "\n", + "# Display findings and recommendations\n", + "print(\"\\nFINDINGS:\")\n", + "for finding in findings:\n", + " print(finding)\n", + "\n", + "print(\"\\nRECOMMENDATIONS:\")\n", + "if recommendations:\n", + " for recommendation in recommendations:\n", + " print(recommendation)\n", + "else:\n", + " print(\"- All necessary data appears to be available and sufficient for the analysis.\")\n", + "\n", + "print(\"\\nNext Steps:\")\n", + "print(\"1. Ensure all required datasets are downloaded and properly formatted\")\n", + "print(\"2. Prepare training and testing datasets based on appropriate temporal splits\")\n", + "print(\"3. Apply the methodology described in the README for fire vulnerability mapping\")\n", + "print(\"4. Evaluate model performance using metrics like precision, recall, and F1-score\")\n", + "print(\"5. Generate predictions for future fire-prone areas\")\n", + "\n", + "print(\"\\nThis script generated several visualization files. Check your directory for the PNG files.\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ee", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..105451b --- /dev/null +++ b/requirements.txt @@ -0,0 +1,16 @@ +earthengine-api>=0.1.347 +numpy>=1.21.0 +pandas>=1.3.0 +geopandas>=0.10.0 +matplotlib>=3.4.0 +seaborn>=0.11.0 +scikit-learn>=1.0.0 +tqdm>=4.62.0 +rasterio>=1.2.0 +folium>=0.12.0 +geemap>=0.16.0 +shapely>=1.8.0 +pyproj>=3.1.0 +requests>=2.26.0 +jupyter>=1.0.0 +notebook>=6.4.0 \ No newline at end of file