exiftool installation

apt.txt

@@ -0,0 +1 @@
+libimage-exiftool-perl

gradio_with_map.py

@@ -3,13 +3,13 @@ import gradio as gr
 import PIL.Image as Image
 import numpy as np
 import cv2
-from ultralytics import ASSETS, YOLOv10
+from ultralytics import YOLOv10
+from exiftool import ExifToolHelper
 from geopy.distance import geodesic
 import folium
 import base64
 import supervision as sv
 import os
-from PIL.ExifTags import TAGS, GPSTAGS
 
 # Constants for image dimensions
 IMAGE_WIDTH = 4000
@@ -19,9 +19,13 @@ IMAGE_HEIGHT = 3000
 model = YOLOv10("weights/best.pt")
 
 # Define the directory for saving uploaded images
-UPLOAD_DIR = 'uploads'  # Or any other directory within your project
+UPLOAD_DIR = './uploads/'  # Or any other directory within your project
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 
+# Debugging: Check exiftool path
+exiftool_path = os.popen("which exiftool").read().strip()
+print(f"ExifTool path: {exiftool_path}")
+
 
 # Function to calculate ground distance from pixel distance
 def calculate_ground_distance(altitude, fov_deg, image_dimension, pixel_distance):
@@ -29,14 +33,12 @@ def calculate_ground_distance(altitude, fov_deg, image_dimension, pixel_distance
     ground_distance = (2 * altitude * np.tan(fov_rad / 2)) * (pixel_distance / image_dimension)
     return ground_distance
 
-
 # Function to get GPS coordinates from offsets
 def get_gps_coordinates(lat, lon, north_offset, east_offset):
     new_location = geodesic(meters=north_offset).destination((lat, lon), 0)
     new_location = geodesic(meters=east_offset).destination(new_location, 90)
     return new_location.latitude, new_location.longitude
 
-
 def extract_xmp_metadata(xmp_data):
     # Parse the XMP data as an XML tree
     root = ET.fromstring(xmp_data)
@@ -57,65 +59,10 @@ def extract_xmp_metadata(xmp_data):
 
     return relative_altitude, gimbal_yaw_degree, gimbal_pitch_degree
 
-
-def extract_gps_info(exif_data):
-    """Extract GPS information from the EXIF data."""
-    gps_info = {}
-    for tag, value in exif_data.items():
-        decoded = TAGS.get(tag, tag)
-        if decoded == 'GPSInfo':
-            for t in value:
-                sub_decoded = GPSTAGS.get(t, t)
-                gps_info[sub_decoded] = value[t]
-    return gps_info
-
-def extract_fov_info(exif_data):
-    """Extract FOV information from the EXIF data."""
-    fov_info = {}
-    
-    for tag, value in exif_data.items():
-        decoded = TAGS.get(tag, tag)
-        
-        # Check for known FOV-related tags
-        if decoded == 'FocalLength':  # Example tag for focal length
-            focal_length = value
-            fov_info['FocalLength'] = focal_length
-        
-        if decoded == 'FocalLengthIn35mmFilm':  # Another example
-            focal_length_35mm = value
-            fov_info['FocalLengthIn35mmFilm'] = focal_length_35mm
-            
-        # Add additional checks for custom FOV-related tags if known
-        # if decoded == 'YourCameraSpecificFOVTag':
-        #     fov_degree = value
-        #     fov_info['FOV'] = fov_degree
-
-    # Calculate FOV if needed (e.g., using focal length and sensor size)
-    if 'FocalLength' in fov_info:
-        # Example calculation for FOV using a known formula:
-        # This example uses a hypothetical sensor size; adjust as needed.
-        sensor_width = 36.0  # mm (example for full-frame sensor)
-        focal_length = fov_info['FocalLength'][0] / fov_info['FocalLength'][1]
-        
-        # Calculate horizontal FOV in degrees
-        fov_info['FOV'] = 2 * np.arctan(sensor_width / (2 * focal_length)) * (180 / np.pi)
-
-    return fov_info
-
-
-def get_decimal_from_dms(dms, ref):
-    """Convert DMS coordinates to decimal format."""
-    degrees, minutes, seconds = dms
-    decimal = float(degrees) + float(minutes) / 60 + float(seconds) / 3600
-    if ref in ['S', 'W']:
-        decimal = -decimal
-    return decimal
-
-
 def save_image_with_metadata(img, img_path):
     # Convert PIL Image to a format that retains EXIF
     img_format = img.format or 'JPEG'
-
+    
     # Save image to a temporary file to preserve metadata
     img.save(img_path, format=img_format)
 
@@ -139,30 +86,56 @@ def predict_image(img, conf_threshold, iou_threshold):
         print(f"Gimbal Pitch Degree: {gimbal_pitch_degree}")
     else:
         print("XMP data not found in the image.")
-
+    
     # Extract EXIF data
     exif_data = img.info.get("exif")
-
-    if exif_data is not None:
-        gps_info = extract_gps_info(exif_data)
-        print("GPS Info:", gps_info)
-
-        # Get latitude and longitude
-        gps_latitude = get_decimal_from_dms(gps_info['GPSLatitude'], gps_info['GPSLatitudeRef'])
-        gps_longitude = get_decimal_from_dms(gps_info['GPSLongitude'], gps_info['GPSLongitudeRef'])
-
-        CAMERA_GPS = (gps_latitude, gps_longitude)
-        print("Camera GPS:", CAMERA_GPS)
-    else:
-        print("EXIF data not found in the image.")
-        return None, "EXIF data not found."
+    try:
+        xmp_data = img.info.get("xmp")
+        #print(xmp_data)    
+    except:
+        print("error loading xmp data")    
+    #print(exif_data)
 
     # Save the image with metadata
-    img.save(img_path)  # Save without EXIF data if not available
-
+    if exif_data:
+        img.save(img_path, exif=exif_data)  # Save the image with its EXIF data
+    else:
+        img.save(img_path)  # Save without EXIF data if not available
+    
     # Convert PIL Image to OpenCV image
     img_cv2 = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
 
+    # Use ExifTool to extract metadata
+    metadata = {}
+    tag_list = [
+        "Composite:FOV",
+        "Composite:GPSLatitude",
+        "Composite:GPSLongitude",
+        "XMP:AbsoluteAltitude",
+        "XMP:RelativeAltitude",
+        "XMP:GimbalRollDegree",
+        "XMP:GimbalYawDegree",
+        "XMP:GimbalPitchDegree"
+    ]
+
+    rel_path = img_path.lstrip("./")
+    #print(rel_path)
+    with ExifToolHelper() as et:
+        for d in et.get_metadata(rel_path):
+            metadata.update({k: v for k, v in d.items() if k in tag_list})
+
+    # Extract necessary metadata
+    CAMERA_GPS = (metadata["Composite:GPSLatitude"], metadata["Composite:GPSLongitude"])
+    RELATIVE_ALTITUDE = float(relative_altitude)
+    GIMBAL_YAW_DEGREE = float(gimbal_yaw_degree)
+    FOV_HORIZONTAL = float(metadata["Composite:FOV"])
+    FOV_VERTICAL = FOV_HORIZONTAL * (IMAGE_HEIGHT / IMAGE_WIDTH)
+    #GIMBAL_PITCH_DEGREE = float(gimbal_pitch_degree)
+    
+    # Convert degrees to radians
+    yaw_rad = np.radians(GIMBAL_YAW_DEGREE)
+    #pitch_rad = np.radians(GIMBAL_PITCH_DEGREE)
+
     # Perform prediction
     results = model.predict(
         source=img_cv2,
@@ -174,7 +147,7 @@ def predict_image(img, conf_threshold, iou_threshold):
     )
 
     detections = sv.Detections.from_ultralytics(results[0])
-
+    
     # Annotate and display image
     for r in results:
         im_array = r.plot()
@@ -184,7 +157,7 @@ def predict_image(img, conf_threshold, iou_threshold):
     building_locations = []
     for i, box in enumerate(detections.xyxy):  # Correct way to iterate through boxes
         # Extract bounding box coordinates and class
-        # print(box)
+        #print(box)
         x_min, y_min, x_max, y_max = box  # Access the first (and only) box
         class_id = int(detections.class_id[i])  # Get class ID as an integer
 
@@ -194,17 +167,11 @@ def predict_image(img, conf_threshold, iou_threshold):
         pixel_distance_x = x_center - IMAGE_WIDTH / 2
         pixel_distance_y = IMAGE_HEIGHT / 2 - y_center
 
-        RELATIVE_ALTITUDE = float(relative_altitude)
-        FOV_HORIZONTAL = float(extract_fov_info(exif_data)[['FOV']])
-        FOV_VERTICAL = FOV_HORIZONTAL * (IMAGE_HEIGHT / IMAGE_WIDTH)
-        
         ground_distance_x = calculate_ground_distance(RELATIVE_ALTITUDE, FOV_HORIZONTAL, IMAGE_WIDTH, pixel_distance_x)
         ground_distance_y = calculate_ground_distance(RELATIVE_ALTITUDE, FOV_VERTICAL, IMAGE_HEIGHT, pixel_distance_y)
 
-        east_offset = ground_distance_x * np.cos(np.radians(gimbal_yaw_degree)) - ground_distance_y * np.sin(
-            np.radians(gimbal_yaw_degree))
-        north_offset = ground_distance_x * np.sin(np.radians(gimbal_yaw_degree)) + ground_distance_y * np.cos(
-            np.radians(gimbal_yaw_degree))
+        east_offset = ground_distance_x * np.cos(yaw_rad) - ground_distance_y * np.sin(yaw_rad)
+        north_offset = ground_distance_x * np.sin(yaw_rad) + ground_distance_y * np.cos(yaw_rad)
 
         building_lat, building_lon = get_gps_coordinates(CAMERA_GPS[0], CAMERA_GPS[1], north_offset, east_offset)
         building_locations.append((building_lat, building_lon, class_id))
@@ -223,7 +190,7 @@ def predict_image(img, conf_threshold, iou_threshold):
 
         folium.Marker(
             location=(building_lat, building_lon),
-            popup=f'Building {i + 1}: {building_status}',
+            popup=f'Building {i+1}: {building_status}',
             icon=folium.Icon(color='red' if class_id == 1 else 'green', icon='home')
         ).add_to(m)
 
@@ -231,7 +198,7 @@ def predict_image(img, conf_threshold, iou_threshold):
     m.save('temp_map.html')
     with open('temp_map.html', 'r') as f:
         folium_map_html = f.read()
-
+    
     encoded_html = base64.b64encode(folium_map_html.encode()).decode('utf-8')
     data_url = f"data:text/html;base64,{encoded_html}"