IM DONE BITCH

detectree2model/predictions/predict.py

@@ -66,4 +66,6 @@ def predict(tile_path, overlap_threshold, confidence_threshold, simplify_value,
 
 def run_detectree2(tif_input_path, store_path, tile_width=20, tile_height=20, tile_buffer=20, overlap_threshold=0.35, confidence_threshold=0.2, simplify_value=0.2): 
     tile_path = create_tiles(input_path=tif_input_path, tile_width=tile_width, tile_height=tile_height, tile_buffer=tile_buffer)
+    print(tile_path)
     predict(tile_path=tile_path, overlap_threshold=overlap_threshold, confidence_threshold=confidence_threshold, simplify_value=simplify_value, store_path=store_path)
+

generate_tree_images/generate_tree_images.py

@@ -4,6 +4,7 @@ import geopandas as gpd
 from shapely.geometry import box
 from rasterio.mask import mask
 from PIL import Image
+from PIL import ImageOps
 import numpy as np
 import warnings
 from rasterio.errors import NodataShadowWarning
@@ -16,26 +17,33 @@ def cut_trees(output_dir, geojson_path, tif_path):
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 
+
     # Load the GeoDataFrame
+
     gdf = gpd.read_file(geojson_path)
 
+
     # Clear the terminal screen
-    os.system('cls' if os.name == 'nt' else 'clear')
+    # os.system('cls' if os.name == 'nt' else 'clear')
 
     # Open the .tif file
     with rasterio.open(tif_path) as src:
         # Get the bounds of the .tif image
         tif_bounds = box(*src.bounds)
-
+        tif_bounds = gpd.GeoDataFrame(geometry=[tif_bounds], crs=gdf.crs)
+        tif_bounds = tif_bounds['geometry'].iloc[0]
         # Get the CRS (Coordinate Reference System) of the .tif image
-        tif_crs = src.crs
+        #tif_crs = src.crs
         
         # Reproject the GeoDataFrame to the CRS of the .tif file
-        gdf = gdf.to_crs(tif_crs)
+       # gdf = gdf.to_crs(tif_crs)
+        #print(tif_bounds.crs.to_epsg())
+        #print(gdf.crs.to_epsg())
 
         # Loop through each polygon in the GeoDataFrame
         N = len(gdf)
         n = int(N/10)
+        print(f"Processing {N} polygons...")
         image_counter = 0
         for idx, row in gdf.iterrows():
             if idx % n == 0:
@@ -46,6 +54,8 @@ def cut_trees(output_dir, geojson_path, tif_path):
             # Extract the geometry (polygon)
             geom = row['geometry']
             name = row['id']
+
+    
             
             # Check if the polygon intersects the image bounds
             if geom.intersects(tif_bounds):
@@ -57,6 +67,8 @@ def cut_trees(output_dir, geojson_path, tif_path):
 
                 # Ensure the array is not empty
                 if out_image.size == 0:
+                    print("Empty image")
+                    gdf.drop(idx, inplace=True)
                     message = f"{round(idx/N*100)} % complete --> {idx}/{N} | Polygon {idx} resulted in an empty image and will be skipped."
                     sys.stdout.write('\r' + message)
                     sys.stdout.flush()
@@ -69,6 +81,8 @@ def cut_trees(output_dir, geojson_path, tif_path):
 
                 # Ensure there are non-zero rows and columns
                 if not np.any(non_zero_rows) or not np.any(non_zero_cols):
+                    print("Non zero rows or columns")
+                    gdf.drop(idx, inplace=True)
                     message = f"{round(idx/N*100)} % complete --> {idx}/{N} | Polygon {idx} resulted in an invalid image area and will be skipped."
                     sys.stdout.write('\r' + message)
                     sys.stdout.flush()
@@ -82,10 +96,13 @@ def cut_trees(output_dir, geojson_path, tif_path):
                 out_image.save(output_path)
                 image_counter += 1
             else:
+                gdf.drop(idx, inplace=True)
+                print("Does not intersect")
                 message = f"{round(idx/N*100)} % complete --> {idx}/{N} | Polygon {idx} is outside the image bounds and will be skipped."
                 sys.stdout.write('\r' + message)
                 sys.stdout.flush()
-                
+    print(len(gdf))
+    gdf.to_file(geojson_path, driver='GeoJSON')
     print(f'\n {image_counter}/{N} Tree images have been successfully saved in the "detected_trees" folder.')
 
 
@@ -101,11 +118,31 @@ def resize_images(input_folder, output_folder, target_size):
             # Open image
             with Image.open(os.path.join(input_folder, filename)) as img:
                 # Resize image while preserving aspect ratio
+                #print("Original image size: ", img.size)
+
                 img.thumbnail(target_size, Image.LANCZOS)
+
+                if img.size[0] < target_size[0] or img.size[1] < target_size[1]:
+        
+                    # Calculate padding dimensions
+                    pad_width = target_size[0] - img.size[0]
+                    pad_height = target_size[1] - img.size[1]
+        
+                    # Calculate padding
+                    padding = (pad_width // 2, pad_height // 2, pad_width - (pad_width // 2), pad_height - (pad_height // 2))
+        
+                    # Pad the image
+                    img = ImageOps.expand(img, padding, fill=(0, 0, 0))
+                
+                #print ("Resized image size: ", img.size)
+
+
                 # Calculate paste position to center image in canvas
                 paste_pos = ((target_size[0] - img.size[0]) // 2, (target_size[1] - img.size[1]) // 2)
+                #print("Paste position: ", paste_pos)
                 # Create a new blank canvas with the target size and black background
                 new_img = Image.new("RGBA", target_size, (0, 0, 0, 255))
+                img = img.convert("RGBA")
                 # Paste resized image onto the canvas
                 new_img.paste(img, paste_pos, img)
                 # Convert to RGB to remove transparency by merging with black background
@@ -115,7 +152,7 @@ def resize_images(input_folder, output_folder, target_size):
                 
             counter += 1
             # Display the counter
-            if counter % 50 == 0:
+            if counter % 100 == 0:
                 message = f"Processed {counter} images"
                 print(message, end='\r')
     

main.py

@@ -12,22 +12,29 @@ import numpy as np
 import ast
 
 def row_to_feature(row):
-    feature = {
+    if (row['geometry'].geom_type == 'Polygon'):
+        coordinates = row['geometry'].exterior.coords.xy
+        coordinate_list = [[x, y] for x, y in zip(coordinates[0], coordinates[1])]
+        feature = {
         "id": row["id"],
         "type": "Feature",
         "properties": {"Confidence_score": row["Confidence_score"], "species": row['species']},
-        "geometry": {"type": "Polygon", "coordinates": [row["coordinates"]]},
-    }
-    return feature
+        "geometry": {"type": "Polygon", "coordinates": [coordinate_list]},
+        }
+        return feature
+
+ 
+   
 
 def export_geojson(df, filename):
+    
     features = [row_to_feature(row) for idx, row in df.iterrows()]
 
     feature_collection = {
         "type": "FeatureCollection",
         "crs": {"type": "name", "properties": {"name": "urn:ogc:def:crs:EPSG::32720"}},
         "features": features,
-    }
+    } 
 
     output_geojson = json.dumps(feature_collection)
 
@@ -35,6 +42,23 @@ def export_geojson(df, filename):
         f.write(output_geojson)
 
     print(f"GeoJSON data exported to '{filename}.geojson' file.")
+    
+def delete_files_in_directory(directory_path: str) -> None:
+    """
+    Delete all files in the given directory.
+
+    :param directory_path: Path to the directory
+    """
+    if not os.path.isdir(directory_path):
+        raise ValueError(f"The provided path '{directory_path}' is not a valid directory.")
+
+    for filename in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, filename)
+        if os.path.isfile(file_path):
+            os.remove(file_path)
+            print(f"Deleted file: {file_path}")
+        else:
+            print(f"Skipped non-file: {file_path}")
 
 def process_image(image_path: str):
     current_directory = os.getcwd()
@@ -43,9 +67,17 @@ def process_image(image_path: str):
     if not os.path.exists(output_directory):
         os.makedirs(output_directory)
 
+    delete_files_in_directory("tiles")
+    delete_files_in_directory("tiles/predictions")
+    delete_files_in_directory("tiles/predictions_geo")
+    delete_files_in_directory("tree_images")
+    delete_files_in_directory("detected_trees")
+
+
+
     run_detectree2(image_path, store_path=output_directory)
 
-    processed_output_df = postprocess(output_directory + '/detectree2_delin.geojson', output_directory + '/processed_delin')
+    processed_output_df = postprocess(output_directory + '/detectree2_delin.geojson', output_directory + '/processed_delin.geojson')
 
     processed_geojson = output_directory + '/processed_delin.geojson'
 
@@ -53,11 +85,13 @@ def process_image(image_path: str):
 
     output_folder = './tree_images'
 
+    processed_output_df = gpd.read_file(processed_geojson)
+
     all_top_3_list = []  # Initialize an empty list to accumulate all top_3 lists
 
     for file_name in os.listdir(output_folder):
         file_path = os.path.join(output_folder, file_name)
-        print(file_path)
+
         probs = classify(file_path)
         top_3 = probs.head(3)
         top_3_list = [[cls, prob] for cls, prob in top_3.items()]
@@ -68,6 +102,9 @@ def process_image(image_path: str):
     # Assign the accumulated top_3_list to the 'species' column of the dataframe
     processed_output_df['species'] = all_top_3_list
 
+    print(processed_output_df.head())
+    print(processed_output_df.columns)
+
     final_output_path = 'result'
     export_geojson(processed_output_df, final_output_path)
 
@@ -128,7 +165,7 @@ def plot_results(geojson_path, image_path):
 
 def greet(image_path: str):
     geojson_path, image_path = process_image(image_path)
-    fig = plot_results(geojson_path, image_path)
+    fig = plot_results (geojson_path, image_path)
     
     return fig
     

polygons_processing/postpprocess_detectree2.py

@@ -315,7 +315,7 @@ def row_to_feature(row):
     return feature
 
 
-def export_df_as_geojson(df, filename="output"):
+def export_df_as_geojson(df, filename):
     features = [row_to_feature(row) for idx, row in df.iterrows()]
 
     feature_collection = {
@@ -326,10 +326,10 @@ def export_df_as_geojson(df, filename="output"):
 
     output_geojson = json.dumps(feature_collection)
 
-    with open(f"{filename}.geojson", "w") as f:
+    with open(f"{filename}", "w") as f:
         f.write(output_geojson)
 
-    print(f"GeoJSON data exported to '{filename}.geojson' file.")
+    print(f"GeoJSON data exported to '{filename}' file.")
 
 def convert_id_to_string(prefix, x):
     return prefix + str(x)
@@ -348,9 +348,12 @@ def postprocess(prediction_geojson_path, store_path):
 
     df["to_drop"] = False
     df["to_merge"] = False
+    print(f"Number of polygons before postprocessing: {len(df)}")
 
     df_res = process([df])
 
+    print(f"Number of polygons after postprocessing: {len(df_res)}")
+
     export_df_as_geojson(df=df_res, filename=store_path)
 
     return df_res